jpd

The trick is to buy headphones with replaceable wires so you don't have to buy new headphones, just new wires.

But was does Tejano music have to do with the internet or instagram?

Doesn't this only encrypt the first line of input? I thought the idea was to generate a pad-file of equal length to the whole file.

    (with-open-file (input input-path)
      (with-open-file (pad pad-path)
        (setq input-buffer (%string-to-octets (read-line input) *encoding*))
        (setq pad-buffer (%string-to-octets (read-line pad) *encoding*))

Also, I'm not sure what (specifically) read-line looks for to stop reading, but if it can occur randomly you could receive errors if this first random new-line occurs before the length of the file's first line. Or at all when using the same pad for many files as you describe. This may be handled by your %octets-to-string handler though.

You could coalesce the other courses.

  Day1: Course1
  Day2: Course2
  Day3: Course3
  Day4: Course1
  etc,...

Besides those already mentioned, there's Dylan, which was originally S-expression based before switching to it's Wirth-style syntax.

Not certain, but the writing style is similar to Orwell's 1984.

The way I speak...

Pleased to meet you. I am an active sporty guy and 'I play on the soccer team'.

Also, the last variation, would be 'I play at The Soccer Team'. Landmarks are (usually) capitalized.

I do not see how creating a doll with a more regular dimensioned body will make boys want to play with them more.

I imagine that the names for for/list and its counterpart came from the scheme let and let*, which are parallel and sequential respectively.

I think he may be thinking of more traditional forms of games. Soccer, Lacrosse, etc.

I always figured that this was because a developer ran into a situation where the concept was naively applied and it ended up biting him. So, instead of staying quiet, he let people know the problems he ran into so that others don't get bitten as well and approach the problem more carefully.

Isn't libc just a set of libraries and therefore not considered a runtime environment? C does have a small runtime environment, but I'd say it's the existence of the function call stack, as well as the on_exit system that's built into the core language.

Instead of angled_brackets<> they should probably try to go with D's style of templates[1], which uses an operater !, to signify its use.

Also, I personally believe that camel case for type names would be a net loss; the underscore separates the words nicely, and I think it's pretty clear from the syntax what is and is not a type name (in my extremely limited experience).

[1]. http://dlang.org/templates-revisited.html

Ah, thanks. I forgot about that.

He needs 'lit' so dcpu_opr() can uniformly return a pointer for all results, including literal values.

Instead of using dcpu.skip, why not just (d->pc += !res)? This way you don't have to call dcpu_step() again before getting to the next instruction and more accurately follow the way the hardware would likely work.

You may also like Mark Twain's "On the Decay of the Art of Lying".

link: http://www.gutenberg.org/ebooks/2572

Keeping silent is a form of a white lie. If it causes trouble, chances are it is something that must be said in order to hold on to your supposed "honesty". The reason white lies exist to keep from causing trouble. It is not a bad thing.

Sadly, searching for "make it rain" does not produce the desired results.

I'd argue that broken analogies are worth mentioning. They do not change the caliber of the point being made by the orginal author, but it is worthwhile to bring it to their attention so that they may fix it later.

"Players don't finish games because they get bored...It was boring...Quests were simple and boring...It might have gotten better, but I'll never know because I got bored..."

You're kind of sending mixed messages here. You say it's not boredom, then you say you quit because you got bored... But I think I understand what you are trying to say. That people stop playing these games because they no longer expect good games, they expect inspired games. If the games just keep repeating the same thing over and over again it's going to start feeling like work.

I think a good example of the problem of repetition is the game reviews for Alice: Madness Returns, where they said the first 5 hours of the game were flawed, yet fun, and then kept going. And going. By the time they reached the end they were just sick of it. If a designer can't make a game that can hold your interest through the entire gameplay they are doing something wrong.

Judging by the text of the hint you gave us, I believe it's trying to make you type:

   var six = numbers[2]

I am not sure where the hangup is, considering I just copy-pasted that from two parts of the hint. Have they described arrays to you yet? Perhaps the problem is that they insufficiently described what an array was and what it did? I have not tried to use the site, so I'm not sure.

If you're willing to share the code, I'm sure many of us would love to see it.

I think your missing the fact that Emacs wont run on this OS.

I agree, it looks like :i-o is the unfortunate result of the generic hyphenation-to-capital-letter routine he has. IO should probably be a special case (:io).

I don't think it's explicitly wrong; I've seen both fib(0) = 1 and fib(0) = 0 before. Wikipedia shows:

   By definition, the first two Fibonacci numbers are 0 
   and 1, and each subsequent number is the sum of the
   previous two. Some sources omit the initial 0, instead 
   beginning the sequence with two 1s.

I'd imagine it's pretty common, especially if you consider CSS, HTML and Javascript different languages. Personally, I use PL/X, and z/Assembly daily, with REXX thrown in every now and then.

As someone who is currently an IBM employee, this is news to me.

Yes, but what's happening in soccer right now, is that the dealer saw a full house, but decided to only count it as a high-card 5.

I've always been a fan of array-based programming languages, but I feel like that most popular ones (J, K) are needlessly unreadable. I discovered Nial a while ago while researching array-based programming languages and found that it was pretty much what I wanted.

I will try to give you an extremely brief introduction here, but you should really download it from their page (http://www.nial.com/) which has a great implementation guide, as well as manuals in their documentation ZIP package.

  > p :+ 1.5 1.6
  > q := 3 4
  > p * q
  4.5 6.4
  > * p q
  4.5 6.4
  > + * p q
  10.9

There exists several forms for writing vectors/lists in Nial:

  s := 3
  v := (3 4)
  m := [2 3 4, 5 6 7]

  > + v
  7
  > + m
  10 18 28
  > each + m
  9 18

In the K tutorial they have psuedo-code which looks like Nial code.

  > v + v
  6 8
  > v eachleft < v
  [false true, false false]
  > v eachright < v
  [false false, true false]

Keep in mind, I am lieing here. true is actually represented as 'l' and false is represented by 'o'. Strange, but it works.

  > v * m
  [6 9 12, 20 24 28]
  > + * v m
  26 33 40

Function currying is done on the left side.

  (2 *) m
  [4 6 8, 10 12 14]

Given a list of cashflows c that come at corresponding times t with a prevailing discount rate d, then ...

  > c := 0.1 0.1 1.1
  > t := 1 2 3
  > pv is op c t d { + * c (d power t) }
  > pv c t 0.9
  0.9729

I don't really follow the last example, and it doesn't translate to Nial because Nial requires the shapes to match up. So giving an array of 4 to PV doesn't work. If they keep it to an array of 3 it does.

  > pv c t (1 0.9 .81)
  .765585
  > pv c t (0.9 .81 .729)
  0.581773

This gets a different answer from what they show though. Shrug.

Nial also has indexing primitives like k.

  > t
  1 2 3
  > t@1
  2
  > m
  [2 3 4, 5 6 7]
  > m@1
  5 6 7

You have to be careful how you define your variables to have indexing work right (which is frustrating). For example:

  > a := [2 3 4, 5 6 7]
  > 1 2 pick a
  ?address
  > b := 2 3 reshape 2 3 4 5 6 7 
  > 1 2 pick b
  7
  > shape a
  2
  > shape b
  2 3
  > shape a@1
  3
  > b@(1 2)
  7

When defined the first way, a doesn't understand the shape of the sublists. So you have to manually touch it to see what it is. Lame.

  > a := 2 3 reshape link a
  > a
  [2 3 4, 5 6 7]

LINK forces a into a single list, and reshape changes the shape of A so the outer-most container understands what it is. '2 3 reshape A' will make a shape that is 2 3, but it wont be what you want.

  > 2 3 reshape [2 3 4, 5 6 7]
  [[2 3 4, 5 6 7, 2 3 4], [5 6 7, 2 3 4, 5 6 7]]

That said, It's likely that the implementation isn't as good/efficient as J or K, but the source code is available.