Lawnmowers

Some people go running for exercise, but not my neighbor. He mows his lawn three times a week. Usually it is in the evening as my toddler is trying to get to sleep. Sometimes I let my lawn go a couple extra days between mowing just to spite him.

Last weekend I was mowing my lawn and I realized that I had different height settings on the front and rear wheels. I set them to the same level, and was amazed that the result seemed so much more even than the previous week. And so I stated paying more attention to the height setting on my mower.

It is actually quite easy to set the height on this mower, it has levers on the front and back wheels, and if you get down close to it there are numbers on the side so you can easily set it where you want. This comes in handy if you happen to be mowing a thick, wet lawn; I have found that my mower will stall out on such a lawn when on a low setting, but if you raise the mower to a higher setting then it will power on through.

The mower has settings from 1 to 6. I used it set at 3 on my front yard, and set at 4 on the back yard, and it looks nice. The front is crisp and low, and is even with my neighbors, so it looks nice. I let the back be a bit longer because the kids like to run around with bare feet and this makes it a bit softer for them.

I read an article a while back (I will link it if I ever find it again) that suggested an easy way to help a lawn that is being choked out by leafy weeds: set your lawn mower to the highest setting for a few weeks and mow a bit more frequently than usual. This will let the grass grow taller and out-compete the weeds, which spread sideways. Then after the grass is nice and thick you can go back to the normal mowing height.

lamport.py

This is a script I wrote in Python to use the ideas expressed by Lamport and Stanislav.

-----BEGIN PGP SIGNED MESSAGE-----
Hash: SHA1

#!/usr/bin/python

#
# (C) 2016 Peter Lambert. 
# You do not have, nor can you ever acquire the right to use, copy or distribute this software; 
# should you use this software for any purpose, or copy and distribute it to anyone or in any manner,
# you are breaking the laws of whatever soi-disant jurisdiction, and you promise to continue doing
# so for the indefinite future.
#

import hashlib
import os
import sys

#
# Comment out the line below with the hash you do not want to use

# sha = hashlib.sha256
sha = hashlib.sha512


def binmessagehash(filename):
    m = open(filename, 'r')
    messagehash = sha(m.read()).hexdigest()
    m.close()    
    return bin(int(messagehash, 16))[2:].zfill(len(messagehash) * 4)
    
def decode(pubkeyfile, sigfile):
    kf = open(pubkeyfile, 'r')
    pubkey = [line.strip().split() for line in kf.readlines()]
    kf.close()
    
    sf = open(sigfile, 'r')
    sig_keys = [line.strip() for line in sf.readlines()]
    sf.close()
    
    binmessage = ''
    
    for k in range(len(sig_keys)):
        key_hash = sha(sig_keys[k].decode('hex')).hexdigest()
        if key_hash in pubkey[k]:
            binmessage += str(pubkey[k].index(key_hash))
        else:
            return 'Bad signature, hash not found for %s' % sig_keys[k]
    
    hexmessage = '%x' % (int(binmessage, 2))
    return hexmessage
    
def encode(privkeyfile, messagefile):
    pkf = open(privkeyfile, 'r')
    key = [line.strip().split() for line in pkf.readlines()]
    pkf.close()
    
    bmess = binmessagehash(messagefile)
    for k in range(len(bmess)):
        print key[k][int(bmess[k])]

def generate_key(payloadbits, strengthbits):
    if '-s' in sys.argv:
        rs = randstr
    else:
        rs = os.urandom
    key = [[rs(int(strengthbits) / 8) for n in [0, 1]] for m in range(int(payloadbits))]
    for k in key:
        print ' '.join(kp.encode('hex') for kp in k)
            
def output_help():
    print '''Usage: 
        ./lamport.py -g PAYLOADBITS STRENGTHBITS > PRIVKEYFILE  
            generates a key
            
        ./lamport.py -g -s PAYLOADBITS STRENGTHBITS > PRIVKEYFILE
            generates a key with the slower, more secure /dev/random
            
        ./lamport.py -p PRIVKEYFILE > PUBKEYFILE
            creates a pubkey from a privkey file
            
        ./lamport.py -e PRIVKEYFILE MESSAGE > ENCODED.TXT
            creates a digital signature
            
        ./lamport.py -d PUBKEYFILE ENCODED.TXT
            decode the digital signature
            
        ./lamport.py -v PUBKEYFILE ENCODED.TXT MESSAGE
            check that encoded is the correct signature for message
    ''' 

def priv_to_pubkey(privkeyfile):
    pkf = open(privkeyfile, 'r')
    for line in pkf.readlines():
        print ' '.join(sha(k.decode('hex')).hexdigest() for k in line.strip().split())
    pkf.close()
    
def randstr(num_bytes):
    stream = open('/dev/random', 'rb')
    res = stream.read(num_bytes)
    stream.close()
    return res

def verify(pubkeyfile, sigfile, messagefile):
    decoded = decode(pubkeyfile, sigfile)
    print decoded
    
    m = open(messagefile, 'r')
    messagehash = sha(m.read()).hexdigest()
    m.close()
    
    if decoded == messagehash:
        print 'Good signature'
    else:
        print 'Bad signature'

if __name__ == "__main__":
    if '-g' in sys.argv and sys.argv[-2].isdigit() and sys.argv[-1].isdigit():
        generate_key(sys.argv[-2], sys.argv[-1])
    elif '-p' in sys.argv:
        priv_to_pubkey(sys.argv[-1])
    elif '-e' in sys.argv:
        encode(sys.argv[-2], sys.argv[-1])
    elif '-d' in sys.argv:
        print decode(sys.argv[-2], sys.argv[-1])
    elif '-v' in sys.argv:
        verify(sys.argv[-3], sys.argv[-2], sys.argv[-1])
    else:
        output_help()
-----BEGIN PGP SIGNATURE-----
Version: GnuPG v1

iQIcBAEBAgAGBQJX89k8AAoJELTi4Nystj0llqwQAJpubTEEl4VysaO/IlPExNFl
mQ+md7cBEAmK3ithZcJSS5XsKXhSWs+w6b0IJRQB0r2XMHu4hZUiRicVubkiKtwc
jqZ8ots+Pr9mzcuw4dlVNH6Avr0WPpcObwCEWXzlLVP27kEeXCPSwPTp0Eh3YAgv
YGOkMvu4Yw2HmzwfNlHAdhdAPuNpW7dOHGwZAzBkeWegZDK/urDp7oEIw8D/DBBz
FbH/eXsRcHzmjk1cOi9lgQyaTZ3qSA+ULriSDM/LCjMNso+fKcxO0Pi7MpdNnxTj
l0KMHndWWaJkiROZ6M9zMyUt68/y4F1sJ0T/qy07msVYC8D7p+hEtOOJfAJuWiZL
VgLZzi5WiV93QwnKrJCrRR72SbPyAL9YGFbS5vBbilxv7dktoXUXnTeUP3Ddvn4B
4rW19wha3AZ5AT+ssuC8TggLzlDKlPLsGQmXEtyk7HAN+ynXnQ3ioHwwPOePzGHG
UfNIoXQnXDTLS4jLD09VXf3gYP27gb3ouT7dhOYQ0yignuE/5vvJ2UuneI52VV0i
pupS/vJ4h7qaKFJfhQmsczGkN0SnhyKjjE5Xi4A0NWHLKtaKU9Wxs0f/xA9b8sJg
hLjf2x1+3bHZeMsIPoxjd3z3xeHOgLj+BRSZTUxTmEZnlz6IaTzjNe5iSHL8ucef
tilzFtS1wA4DSSWPDbOg
=WGyj
-----END PGP SIGNATURE-----

Constructing Digital Signatures from One Way Functions

This is something I pulled from a pdf a while ago. It was referenced on Loper-OS, and so I thought it would be worthwhile to de-pdf-enate it.

-----BEGIN PGP SIGNED MESSAGE-----
Hash: SHA1

Op. 52

Constructing Digital Signatures from One Way Function

Leslie Lamport
Computer Science Laboratory
SRI International

18 October 1979
CSL 98

333 Ravenswood Ave. Menlo Park, California 94025
(415) 326-6200 Cable: SRI INTL MPK TWX: 910-373-1246

1. Introduction

A digital signature created by sender P for a document m is data
item o_p(m) having the property that upon receiving m and o_p(m) one can
determine (and if necessary prove in court of law) that P generated the
document m .

A one way function is function that is easy to compute, but whose
inverse is difficult to compute [1]. More precisely one way function T is
a function from set of data objects to a set of values having the following
two properties:

        1. Given any value v , it is computationally infeasible to find a
        data object d such that T(d) = v .
        2. Given any data object d , it is computationally infeasible to find
        a different data object d' such that T(d') = T(d) .

If the set of data objects is larger than the set of values, then such a
function is sometimes called one way hashing function.

We will describe a method for constructing digital signatures from such a
one way function T . Our method is an improvement of a method devised by
Rabin [2]. Like Rabin's, it requires the sender P to deposit a piece of
data o in some trusted public repository for each document he wishes to
sign. This repository must have the following properties:

        - o can be read by anyone who wants to verify P's signature.
        - It can be proven in court of law that P was the creater of o .

Once o has been placed in the repository, P can use it to generate a
signature for any single document he wishes to send.

Rabin's method has the following drawbacks not present in ours.

        1. The document must be sent to single recipient Q , who then
        requests additional information from P to validate the signature.
        P cannot divulge any additional validating information without
        compromising information that must remain private to prevent
        someone else from generating new document m' with valid
        signature o_p(m') .

        2. For a court of law to determine if the signature is valid, it is
        necessary for P to give the court additional private information.

This has the following implications.
        - P -- or a trusted representative of P must be available
        to the court.
        - P must maintain private information whose accidental
        disclosure would enable someone else to forge his signature on
        a document.

With our method, P generates a signature that is verifiable by anyone,
with no further action on P's part. After generating the signature, P can
destroy the private information that would enable someone else to forge his
signature. The advantages of our method over Rabin's are illustrated by the
following considerations when the signed document m is a check from P
payable to Q .

        1. It is easy for Q to endorse the check payable to third party
        R by sending him the signed message "make m payable to R ".
        However, with Rabin's scheme, R cannot determine if the check m
        was really signed by P , so he must worry about forgery by Q as
        well as whether or not P can cover the check. With our method,
        there is no way for Q to forge the check, so the endorsed check
        is as good as check payable directly to R signed by P .
        (However, some additional mechanism must be introduced to prevent
        Q from cashing the original check after he has signed it over to
        R .)

        2. If P dies without leaving the executors of his estate the
        information he used to generate his signatures, then Rabin's method
        cannot prevent Q from undetectably altering the check m -- for
        example, by changing the amount of money payable. Such posthumous
        forgery is impossible with our method.

        3. With Rabin's method, to be able to successfully challenge any
        attempt by Q to modify the check before cashing it, P must
        maintain the private information he used to generate his signature.
        If anyone (not just Q ) stole that information, that person could
        forge a check from P payable to him. Our method allows P to
        destroy this private information after signing the check.

2. The Algorithm

We assume a set M of possible documents, set K of possible keys [footnote 1],
and set V of possible values. Let S denote the set of all subsets of
{1, ... , 40} containing exactly 20 elements. (The numbers 40 and 20 are
arbitrary, and could be replaced by 2n and n. We are using these numbers
because they were used by Rabin, and we wish to make it easy for the reader to
compare our method with his.)

We assume the following two functions.
        1. function F : K -> V with the following two properties:
                a. Given any value v in V , it is computationally infeasible
                to find a key k in K such that F(k) = v .
                b. For any small set of values v_1, ... , v_m , it is easy to
                find a key such that F(k) is not equal to any of the
                v_i .
        2. A function G : M -> S with the property that given any document
        m in M , it is computationally infeasible to find document
        m' /= m  such that G(m') = G(m)
        
For the function F , we can use any one way function T whose domain is
the set of keys. The second property of F follows easily from the second
property of the one way function T . We will discuss later how the function
G can be constructed from an ordinary one way function.

For convenience, we assume that P wants to generate only a single
signed document. Later, we indicate how he can sign many different documents.
The sender P first chooses 40 keys k_i such that all the values F(k_i) are
distinct. (Our second assumption about F makes this easy to do.) He puts
in public repository the data item o = (F(k_1), ... , F(k_40)) . Note that
P does not divulge the keys k_i , which by our first assumption about F
cannot be computed from o .

To generate a signature for a document m , P first computes G(m) to
obtain a set [i_1, ... , i_20] of integers. The signature consists of the 20
keys k_i_1, ... , k_i_20 . More precisely, we have o_p(m) =  (k_i_1, ... , k_i_20) ,
where the i_j are defined by the following two requirements:
        (i) G(m) =  {i_1, ... , i_20}
        (ii) i_1 < ... < i_20
After generating the signature, P can destroy all record of the 20 keys k_s
with s not in G(m) .

To verify that 20-tuple (h_1, ... , h_20) is valid signature o_p(m)
for the document m, one first computes G(m) to find the i_j and then uses
o to check that for all j , h_j is the i_j^th key. More precisely, the
signature is valid if and only if for each j with 1 _< j _< 20 :
F(h_j) o_i_j , where o_i denotes the i^th component of o , and the i_j are 
defined by the above two requirements.

To demonstrate that this method correctly implements digital signatures,
we prove that it has the following properties.
        1. If P does not reveal any of the keys k_i , then no-one else can
        generate valid signature o_p(m) for any document m .
        2. If P does not reveal any of the keys k_j except the ones that
        are contained in the signature o_p(m) , tnen no-one else can
        generate valid signature o_p(m') for any document m' /= m .

The first property is obvious, since the signature o_p(m) must contain
20 keys k_i such that F(k_i) = o_i , and our first assumption about F states
that it is computationally infeasible to find the keys k_i just knowing the
values F(k_i) .

To prove the second property, note that since no-one else can obtain any
of the keys k_i , we must have o_p(m') = o_p(m) . Moreover, since the o_i are
all distinct, for the validation test to be passed by o_p(m') we must also
have G(m') = G(m) . However, our assumption about G states that it is
computationally infeasible to find such document m' . This proves the
correctness of our method.

For P to send many different documents, he must use a different o for
each one. This means that there must be sequence of 40-tuples o_1, o_2, ...
and the document must indicate which o_i is used to generate that document's
signature. The details are simple, and will be omitted.

3. Constructing the Function G

One way functions have been proposed whose domain is the set of documents
and whose range is a set of integers of the form {0, ... , 2^n - 1} for any
reasonably large value of n . (It is necessary for n to be large enough to
make exhaustive searching over the range of T computationally infeasible.)
Such functions are described in [1] and [2]. The obvious way to construct the
required function G is to let T be such a one way function, and define
G(m) to equal R(T(m)) , where R : {0, ... , 2^n - 1} -> S .

It is easy to construct function R having the required range and
domain. For example, one can compute R(s) inductively as follows:
        1. Divide s by 40 to obtain quotient q and a remainder r
        2. Use r to choose an element x from {1, ... , 40} (This is
        easy to do, since 0 _< r _< 40 .)
        3. Use q to choose 19 elements from the set {1, ... , 40} - {x} as
        follows:
                a. Divide q by 39 to obtain quotient ...
It requires careful analysis of the properties of the one way function T
to be sure that the resulting function G has the required property. We
suspect that for most one way functions T , this method would work. However,
we cannot prove this.

The reason constructing G in this manner might not work is that the
function R from {0, ... , 2^n} into S is a many to one mapping, and the
resulting "collapsing" of the domain might defeat the one way nature of T .
However, it is easy to show that if the function R is one to one, then
property (ii) of T implies that G has the required property. To construct
G we need only find an easily computable one to one function R from
{0, ... , 2^n - 1} into S , for a reasonably large value of n .

We can simplify our task by observing that the function G need not be
defined on the entire set of documents. It suffices that for any document
m , it is easy to modify m in a harmless way to get new document that is
in the domain of G. For example, one might include meaningless number as
part of the document, and choose different values of that number until he
obtains a document that is in the domain of G . This is an acceptable
procedure if (i) it is easy to determine whether a document is in the domain,
and (ii) the expected number of choices one must make before finding a
document in the domain is small.

With this in mind, we let n = 40 and define R(s) as follows: if the
binary representation of s contains exactly 20 ones, then R(s) = {i : the
i^th bit of s equals one} , otherwise R(s) is undefined. Approximately
13% of all 40 bit numbers contain exactly 20 ones. Hence, if the one way
function T is sufficiently randomizing, there is a 0.13 probability that any
given document will be in the domain of G . This means that randomly
choosing documents (or modifications to a document), the expected number of
choices before finding one in the domain of G is approximately 8. Moreover,
after 17p choices, the probability of not having found document in the
domain of G is about 1/10^p. (If we use 60 keys instead of 40, the expected
number of choices to find document in the domain becomes about 10, and 22p
choices are needed to reduce the probability of not finding one to 1/10^p.)

If the one way function T is easy to compute, then these numbers
indicate that the expected amount of effort to compute G is reasonable.
However, it does seem undesirable to have to try so many documents before
finding one in the domain of G . We hope that someone can find more
elegant method for constructing the function G , perhaps by finding a one to
one function R which is defined on a larger subset of {0, ... , 2^n} .

Note; We have thus far insisted that G(m) be a subset of
{1, ... , 40} consisting of exactly 20 elements. It is clear that the
generation and verification procedure can be applied if G(m) is any proper
subset. An examination of our correctness proof shows that if we allow G(m)
to have any number of elements less than 40, then our method would still have
the same correctness properties if G satisfies the following property:
        - For any document m , it is computationally infeasible to find a
        different document m' such that G(m') is a subset of G(m) .
By taking the range of G to be the collection of 20 element subsets, we
insure that G(m') cannot be proper subset of G(m) . However, it may be
possible to construct a function G satisfying this requirement without
constraining the range of G in this way.

REFERENCES

[1] Diffie, W. and Hellman, M. "New Directions in Cryptography".
_IEEE Trans. on Information Theory IT-22_ (November 1976),
644-654.

[2] Rabin, M. "Digitalized Signatures", in _Foundations of
Secure Computing_, Academic Press (1978), 155-168.

FOOTNOTES

[1] The elements of K are not keys in the usual cryptographic sense, but are
arbitrary data items. We call them keys because they play the same role as
the keys in Rabin's algorithm.

- ---

Editor's note: 

Some characters in the original paper were changed to members of the 
Roman alphabet. 

/= takes the place of the "not equal" symbol.
_< takes the place of the "less than or equal" symbol.
-----BEGIN PGP SIGNATURE-----
Version: GnuPG v1

iQIcBAEBAgAGBQJX8l0SAAoJELTi4Nystj0lHlcP/jfrI7hl6urPXXh3dShYxN62
vY/NfuL2WDK0bjHA65EoDN0u8MEZ7CuVtm+Rzh6GRYyUTLyZtowWFNy3mDD5aMl0
zePELZ4w6aOr7zRcwnBF5v+tHV7y3YL8yyforLYU6+1CYRwqu/1UZRyeaV9QfBA+
jYDEyxuR8zVTJ+JKlM8PtAGEi96KsuZiajP21jlvm0lN4/5bJ7ASBFYTqYiI6pwH
QOE1QaBKFHmTKZTcF/BkrE1J13ewgpqNu4as2aepexsSW7hadbQRVNl5r3lABohd
3bDyPYlUcZHf/XZSQX+u0oxLUkdjKhDGyNDQXIdBisNU04jqxwN1wZ+IvZYLRH25
u7IkSq+cCwaA8vpDHzviRV+Hp+9u4GAqsJo5TYuavQ8mMQDjN93ji1M0CHM54E96
nFUIvAHNbdsyaQlNuFek+/xFinhFiAERbO1c9SggyxAB1Ct6uyOycgTW5WYfFZrR
wiQ9Q9YYVX2CqciERj/AUiliSF/tM50+bEJdrHdA2CASlUKDrTmPtiidV9HNvNjE
efakV7MsKytCjNJM3Ay6Wtm5nd36YmBOKu4g3PtG8huUr/EXYEeIPGaVWUn3tKQF
X2SvUjnHBj6XU8oe7X3ZKGO/iNYYzCyE9FfrE/Dqu4FZbg9YdJL0fPMX9Ad3GM5A
7f97Wy9HTnjzyuL1IVwF
=VRzi
-----END PGP SIGNATURE-----

Movie Review - Deadpool 2

Deadpool 2 is a good comic book movie.

If you have not seen the first Deadpool (What are you doing, go watch it, it is really funny!), the premise is that Deadpool (played by Ryan Reynolds) is a contract killer with a sense of humor, he participated in some experimentation which activated his "mutant powers" (this is the X-men universe) so he can move with almost-as-fast-as-a-speeding-bullet speed and he heals at an extraordinary rate (like Wolverine).

There were quite a few funny moments, many of them references to other comic book franchises. There was some well-executed breaking of the fourth wall, which is nice to see as that is one of the things the character of Deadpool is known for. I like that the Deadpool movies have accepted the 'R' rating, it lets them go all out in their fights; sometimes other comic book movies seem to be pulling their punches a bit to avoid that "violence" tag. There was some blood, Deadpool is a contract killer who really enjoys killing people, but it was not overdone.

The plot was fairly simple, and some of the plot points seemed to be telegraphed from a ways away, but there was enough room for the main character to develop a bit while retaining his bawdy humor.

And there is a character named Peter, which is always a good thing :)

-

Oo De Lally - Guitar Chords

Oo De Lally
By Roger Miller

G              .            C                   G
Robin Hood and Little John, walkin’ through the forest

G               .                 D               G   . . .
Laughin’ back-n-forth at what the other’ne has to say

G           .               C                  G
Reminiscin’ this-n-that an’ havin’ such a good time

G           .           D            G   . . .
Oo-De-Lally Oo-De-Lally golly what a day


G
Never ever thinkin’ there was danger in the water they were

C                                  
Drinkin’ they just guzzled it down

A
Never dreamin’ that a schemin’ sheriff and his posse was a 

D7                .                \ \ \ \
Watching them and gatherin’ around


G              .            C                   G
Robin Hood and Little John, runnin’ through the forest

G              .            D             G   . . .
Jumpin’ fences dogin’ trees tryin’ to get away

G             .          C                G
Contemplatin’ nothin but escapin’ finally making it

G           .           D            G   . . .
Oo-De-Lally Oo-De-Lally golly what a day


G           C           D7           G   . . .
Oo-De-Lally Oo-De-Lally golly what a day

-

Gorsuch and Trump

Back in 2017, when President Trump took office and nominated Neil Gorsuch to fill the vacancy in the supreme court, I noted that Gorsuch had a much more restrained outlook on federal power than Trump. I even predicted (if only I had this blog going at the time so I could link it ... oh well, maybe next time!) that at some point during Trump's tenure he would be trying to do something controversial and the man he nominated would be the swing vote to say "No, you really don't have the power to do that."

Well, it has happened. Just a couple weeks ago I saw the news Neil Gorsuch joins liberals in 5-4 decision. I like that Gorsuch is already asserting his ability to make decisions based on his own principles rather than just following the party line. It looks like the nomination of Gorsuch to the Supreme Court may be one of the best things to come out of the Trump Presidency.

-

A Return to Blogging

Some years ago I started this blog. The vague memories let me know that it did not last long, and I do not think there was much lost in its passing. The posts are all gone, I suppose I deleted them, or they got lost somewhere? Anyway, the important thing is that this is an empty slate.

Recently I have been thinking that I should start a blog, and I have been considering the ways to go about doing that. I happened to stumble upon this blog that I had forgotten about, and it seems like a convenient place to start. In the future, if this goes well (or rather, if I can stick with it), I will consider setting up an actual blog somewhere like Pizarro.

Welcome to my new adventure!

-

Fried Chicken Tenders

This is one of my favorite ways to make chicken. It is a bit time consuming and messy to make, but the chicken comes out tender and delicious at the end.

Ingredients:

• 1-2 pounds chicken tenders (you can substitute chicken breast cut into tender-sized strips if that is all you have)
• 2 cups cooking oil (or however much you need to get about 1/2 inch oil in the bottom of your frying pan)
• 1/2 cup flour
• 1/2 cup bread crumbs
• 1/2 tablespoon salt
• 1/2 tablespoon pepper
• 1 tablespoon paprika
• 1 tablespoon dried parsley
• 1 egg

Put the oil into the frying pan, heat to medium/medium-high. The oil should be hot enough to sizzle when you put the chicken in, but if it spatters any then you have it too high.

Crack the egg into a bowl, beat, set aside.

In another bowl, mix the flour, bread crumbs, salt, pepper, paprika, and parsley. Pour the mix onto a plate.

Rinse the chicken in cold water, pat dry with paper towel. Dip the chicken in the egg, then roll it in the flour mix. Place the chicken in the pan, a couple pieces at a time (do not crowd the chicken or it won't cook evenly) for a couple minutes per side, until golden brown. Remove to a plate.

Enjoy!

-

Genji's Steakhouse

Today for lunch I went with a couple co-workers to the Genji's Steakhouse. Genji's is one of these Japanese styled places where they cook the food on a grill in front of you. This is the first time I have been to this location. I ordered the lunch chicken teriyaki. It came with a nice set of courses, starting with soup and then salad, followed by some grilled vegetables with a ginger sauce to dip them in, a bowl of rice, and then the meat entree.

While the food was filling, and the vegetables were nicely done, I was a bit underwhelmed. I was expecting more flair from the cook from the hype I had been given about eating here, but he basically came in, silently cooked the food, and left. The rice was a bit dry for my taste. And the chicken sauce seemed much saltier than I cared for.

Overall, I did not think the experience was worth the price; the lunch serving was about $14, I would say it would be worth more like $8. Dinner servings are in the $20-30 range. As my other co-worker Duong put it: "If I want to eat stir fried meat on fried rice, there are lots of other places to get it for much cheaper."

-

Korihor

The teachings of Korihor (Book of Mormon, The Book of Alma, Chapter 30):

O ye that are bound down under a foolish and a vain hope, why do ye yoke yourselves with such foolish things? Why do ye look for a Christ? No man can know of anything which is to come.

Behold, these things which ye call prophecies, which ye say are handed down by holy prophets, behold, they are foolish traditions of your fathers.

How do ye know of their surety? Behold, ye cannot know of things which ye do not see; therefore ye cannot know that there shall be a Christ.

Ye look forward and say that ye see a remission of your sins. But behold, it is the effect of a frenzied mind; and this derangement of your minds comes because of the traditions of your fathers, which lead you away into a belief of things which are not so.

There can be no atonement made for the sins of men, but every man fares in this life according to the management of the creature; therefore every man prospers according to his genius, and every man conquers according to his strength; and whatsoever a man does is no crime.

When a man is dead, that is the end thereof.

Why do I go about perverting the ways of the Lord? Why do I teach this people that there shall be no Christ, to interrupt their rejoicings? Why do I speak against all the prophecies of the holy prophets? Because I do not teach the foolish traditions of your fathers, and because I do not teach this people to bind themselves down under the foolish ordinances and performances which are laid down by ancient priests, to usurp power and authority over them, to keep them in ignorance, that they may not lift up their heads, but be brought down according to thy words.

Ye say that this people is a free people. Behold, I say they are in bondage. Ye say that those ancient prophecies are true. Behold, I say that ye do not know that they are true.

Ye say that this people is a guilty and a fallen people, because of the transgression of a parent. Behold, I say that a child is not guilty because of its parents.

And ye also say that Christ shall come. But behold, I say that ye do not know that there shall be a Christ.

And ye say also that he shall be slain for the sins of the world — And thus ye lead away this people after the foolish traditions of your fathers, and according to your own desires; and ye keep them down, even as it were in bondage, that ye may glut yourselves with the labors of their hands, that they durst not look up with boldness, and that they durst not enjoy their rights and privileges.

Yea, they durst not make use of that which is their own lest they should offend their priests, who do yoke them according to their desires, and have brought them to believe, by their traditions and their dreams and their whims and their visions and their pretended mysteries, that they should, if they did not do according to their words, offend some unknown being, who they say is God — a being who never has been seen or known, who never was nor ever will be.

This seems to make logical sense. But, sadly, in the Book of Mormon this man is cast as a villain and his teachings are rejected.

-

The Problem with the World Today

I give you a picture:

Here is a baby who just wants some attention, and there is her dad, the center of her mortal attention, who is completely ignoring her and dinking on his phone instead.

And that is what is wrong with the world today: the older generation is focused on themselves instead of interacting with the upcoming generation. There are too many people who would rather stare unblinking into the glowing device in their hand than interact with other people. And society as a whole is suffering.

Now, the question is: what can I do differently? Are there times that I could put down the phone, turn off that video game, put down the TV remote, and have human interaction with my children to help them grow into productive members of society?

-