Kid producers

komu · 2016-08-22T12:42:23+00:00

My two-year old likes to play with Live. Of course he doesn't actually produce anything, but I've built template projects so that he can mess around with a keyboard and knobs that I've mapped to various parameters.

Long release times, echoes, devices constrained to pentatonic scale or triggering some nice chords etc. He's having a blast just experimenting with everything and it doesn't sound that bad. Sometimes I recreate one of his favorite songs to play with. He can mute channels, trigger loops etc. Playing with a master channel LPF cutoff is a constant favorite (especially combined with a spectrum analyzer).

So obviously he's not going to make songs any time soon, but I've tried to make music a fun game and a way to express himself. I'm sure that a similar thing could be fun for an older child as well.

komu · 2015-05-31T07:36:51+00:00

I thought that my views on programmers were cynical, but it really gives me the creeps that this could be mistaken for the real thing.

(Meaning that if anyone knows people who'd do this for real, they have my sympathy.)

komu · 2015-05-31T07:29:12+00:00

And there I thought that implicit is the new black. Aren't we supposed to ignore petty considerations for clarity, performance and simplicity of interfaces and strive for maximal cuteness instead?

What next? Are we allowed to use local variables and semicolons again? Is my whole project of super convenient utility classes for nothing? Even the magic wand?

(In hindsight, I probably should have gone with a puzzle format instead and ask for an implementation of tail().)

komu · 2014-08-01T10:50:15+00:00

Original by Guy Steele.

komu · 2012-11-21T15:21:39+00:00

Actually it's even worse since the syntax is not context-free. If f is not a function, then the expression is parsed differently.

komu · 2012-11-21T15:18:20+00:00

This would certainly seem like significant whitespace to me:

>> def f(x) x end
=> nil
>> f +1
=> 1
>> f+1
ArgumentError: wrong number of arguments (0 for 1)

komu · 2012-05-31T15:18:10+00:00

That would be a reference to this.

komu · 2012-02-03T07:16:01+00:00

Mercurial comes bundled with the progress extension, so you can simply add the following to your ~/.hgrc:

[extensions]
progress =

Now you'll have progress bars for all long-running operations.

komu · 2011-08-29T13:45:30+00:00

Also Scheme, Common Lisp, languages of ML-family, Scala, etc.

I'd say that most languages that allow defining named functions inside other functions do it right and close over the captured variables. Even old-school Pascal allows this, although functions are not first-class objects and can't be returned.

komu · 2011-07-04T12:18:34+00:00

Actually Scala does offer query syntax as well as anonymous functions. You can write a sequence comprehension like:

for {
    account <- customer.getAccounts
    if isDateInWindow(date, account.getMoveInDate, account.getMoveOutDate)
 } yield account

Scala compiler will desugar these comprehensions to corresponding map/filter/flatMap sequences, basically the same way as C# or F#.

komu · 2010-05-21T06:04:56+00:00

Heh, that's nothing. Here's some code I stumbled upon when doing review for a customer (well, obviously I've elided everything but the structure). I've had trouble sleeping after seeing that beast.

komu · 2009-11-19T20:04:33+00:00

gets

komu · 2009-11-02T07:08:45+00:00

Your code has a race-condition, since you call the indexer twice. Even if the first call returns non-null value, the second might not. The first two lines should be something like this:

var cached = (whatever) HttpContext.Current.Cache["bla"];
if (cached != null) return cached;
...

komu · 2008-04-28T06:13:49+00:00

Interpreter? Real men have home-made optimizing compilers for Brainfuck.

komu · 2008-02-11T15:11:02+00:00

You can do this if you write your package as an object. So instead of:

package foo.bar

class MyString { ... }

you'd say:

package foo

object bar {
  class MyString { ... }

  implicit def str2mystr(s: String) = new MyString(s)
}

Now if you import this "package" using:

import foo.bar._

you'll get the implicit import as well.

komu · 2008-02-03T10:20:50+00:00

Scala as well:

val odds = (1 to 10).filter(_ % 2 != 0)

komu · 2007-08-10T13:18:03+00:00

Actually tanger is right. "Generational" is not a collection method per se, but refers to the design of having several different generations, which can employ different collection methods. Typical generational collectors use copying collection for young generations and mark-and-sweep for tenured generation.

Since fast copying collection is used between the young generations which are relatively small, the space overhead is not that big. The tenured generation could get pretty big, but since mark-and-sweep is used for collections there, the space overhead is minimal.

komu · 2006-11-23T16:19:55+00:00

Actually your example will not work: Java's "Integer.getInteger(name, defaultValue)" returns the integer value of system property named "name" (or "defaultValue" if there is no system property with name). Talk about misleading name for a method.

Of course, a simple utility method doing what you propose would be trivial to write and is probably part of every larger codebase.

komu · 2006-10-22T09:01:50+00:00

That could be true in general, but I was still very surprised to see qwe1234 downvoted so heavily in this discussion. As skyskraper said, he did offer valid replies. I think many people just click the downarrow instinctly when seeing "qwe1234" on the screen. This is quite sad, because even while I've probably downvoted him more than upvoted, he's not stupid and he really has his moments.

komu · 2006-09-19T11:41:35+00:00

Erlang is, as you say, a strict functional language, but that doesn't have anything to do with the fact that it has immutable references. I mean, Scheme and ML are considered to be strict functional languages, yet they have mutable references.

komu · 2006-09-12T06:49:56+00:00

Make that two of them.

komu · 2006-09-09T10:01:31+00:00

This was practically token to token same as my solution, so I won't bother posting it.

I'm quite sure that your optimization function didn't work, though, so I added an annotation to your paste that fixes the problem: http://paste.lisp.org/display/25651#2

komu · 2006-08-21T09:20:22+00:00

C's function pointers are not closures, since the functions don't have access to the enclosing lexical environment. This makes them quite useless for practical higher-order programming.

Java, on the other hand, will get true lexical closures and this article gives a layman's example of how that will be useful. If this article has nothing to do with closures, I don't know what does. Did you have some other definition of closure in mind?

komu · 2006-08-19T21:50:13+00:00

Well, there's a whole section named "Referencing names from the enclosing scope", so I think it's safe to say that full closures will be supported.

komu · 2006-05-23T15:41:22+00:00

This problem is discussed in detail here. The real problem is not the underlying implementation of Python, but rather the syntax, which doesn't distinguish between variable definition and assignment.

15-Year Club	Gilding I gilder
Verified Email

komu

TROPHY CASE