Oliver Steele

This PHP code https://github.com/osteele/wideurl.com/blob/master/wideurl.php turns e.g. http://osteele.com/archives/2006/04/wideurl into `http:​//w-i-d-e-u-r-l.com/aitch-tee-tee-pea-colon-double-slash-oh-ess-tee-double-ee-ell-ee-dot-see-oh-em-slash-aye-are-see-aitch-eye-vee-ee-ess-slash-two-double-zero-six-slash-zero-four-slash-doubleyou-eye-dee-ee-you-are-ell`. It was loosely inspired by a BBC broadcast I heard during the very early days of the web. The announcer said something like “If you would like to learn more about this radio program, enter the following into your browser: aitch aitch tee pea colon forwards-slash forwards-slash bee bee see period see oh em forwards-slash — oh, never mind.” My hosting provider eventually took it down, because URL redirectors can be used for phishing.

My favorite pair of silly LISP function names derived from CAR and CDR is RPLACA and RPLACD. Then of course there's the whole family of derived function names CAAR, CADR, CDAR, CADADR, CADDDDR, CAAAAR, etc. I wonder if that's what inspired Oliver Steele's "The Aargh Page": http://osteele.com/words/aargh http://blog.osteele.com/2005/12/aargh/ Even sillier is LOGO's alternative to CAR and CDR: FIRST and BUTFIRST. As in "BUTFIRST recursion" (giggle). https://en.wikipedia.org/wiki/List_of_MicroWorlds_Logo_commands#butfir…

With Emacs, the languages change but the tool stays the same, you just extend it. In a way akin to how programming enhances my mind to be able to solve tough problems, emacs enhances my capacity to hack by letting me hack the tool itself. Oblig reference to classic essay on that topic: http://www.osteele.com/posts/2004/11/ides

this 2004 post by oliver steele remains one of the best things i've read on the topic: http://www.osteele.com/posts/2004/11/ides key quote: "In fact, the most powerful languages may initially have the least powerful tool support. The reason for this is that the language developer, like the language adopter, has to make a choice: whether to dedicate limited development resources towards language features, or towards tool support."

Here is a great functional JavaScript library if you don't want to build it up yourself: http://osteele.com/sources/javascript/functional/

Great tool. I built something similar for an internal project at my startup inspired by these two projects by Oliver Steele: http://osteele.com/tools/rework/ http://osteele.com/tools/reanimator/

If you already know all about higher-order programming and just want a javascript library with all the haskell/ML-style goodness, I highly recommend O. Steele's Functional library: http://osteele.com/sources/javascript/functional/ If nothing else, then his lambda() implementation with strings should be enough to convince you to use it.

> It would be great to have a tool that visualizes existing REs, I think. This one is pretty cool to play around with, not sure how useful it is in practice though: http://osteele.com/tools/reanimator/

I would say that there are two important things to consider: 1. Understanding how a compiler works without getting bogged down by programming language details - This means that you should try and look at compilers written in Standard ML or Ocaml (my favorite), since that would be much easier to follow. For example -- a datatype can be much more succinctly expressed as type any_value = Int | String | Float rather than across 4 classes (as in the Java case). 2. Start small, and understand it in chunks. For these, a lot of web based resources are ideal. For example, to understand regular expressions, it would be nice if you were able to visualize them, and play around with them visually - http://osteele.com/archives/2006/02/reanimator I would also look at simple examples of interpreters, and build up from that, looking at examples of toy compilers: http://min-caml.sourceforge.net/index-e.html These will help, of course alongside a book like Appel's or the Dragon Book.

You could improve the usability of this library (or FP in PHP in general), by implementing 'string lambdas' such as those found in Oliver Steele's Functional.js[0], which was a clever, if controversial, workaround for Javascript's lack of a concise anonymous function syntax at the time. For example function($n) use ($partial) { return $partial($n - 1) + $partial($n - 2); could become 'partial(n - 1) + partial(n - 2)' Compiling the string lambda to a function can be memoized with the string itself as the key (as many regex implementations do with the regex text) so each is only ever compiled once. [0] http://osteele.com/sources/javascript/functional/

I write code like that. I tend to have a good idea of what the code should be doing, and write it out, char by char, like prose. I also avoid IDEs and prefer text editors. In the twenty-five years of programming, I've not found an IDE I like, and I suspect I'm a langauge-maven than a tool-maven (http://osteele.com/posts/2004/11/ides) (as long as I can type, I can try out a new language; I don't have to wait for a specific IDE to come along first). Edit: add a link about language-mavens vs. tool-mavens.

I knew I've seen it before somewhere. NVI posted an example [1] below [2] where it can be seen live. ________ [1] http://osteele.com/tools/reanimator/ [2] https://news.ycombinator.com/user?id=NVI

A couple of years ago I saw http://osteele.com/tools/reanimator/, OpenLaszlo based RegExp tester. The animation on tabbing between text fields was unusual and interesting. I implemented a similar effect using JS & CSS, and made Chrome and Safari extensions. I released it just two days ago.

This reminds me a lot of the regular expression reAnimator: http://osteele.com/tools/reanimator/.

Unfortunately it seems to be broken now, but reAnimator was an awesome regex visualization tool (http://osteele.com/tools/reanimator/). It let you enter a regex and would display the state machine similar to this, but then it would also let you enter a string and it would animate the progress of the string matching (or not) against the state machine as you enter each character.

No mention of pandas or nltk? I'd never heard of pattern before, and while it looks like it's a nice bundle of features, I'm concerned by the fact it references pyWordNet by name even though it hasn't been an independent project since 2006 (http://osteele.com/projects/pywordnet/). Has anyone actually used it?

Circular look-up table, reminiscent of Oliver Steele's FizzBuzz Station: http://osteele.com/archives/2008/02/fizzbuzz-station

ReWork is my go-to tool when I need to do anything with regexps. http://osteele.com/tools/rework/

Alternatively there is also Oliver Steele's functional javascript which is neat: http://osteele.com/sources/javascript/functional/

just "git commit" after that, not "git commit README.md" edit: it's infuriating that yc won't let me reply to you, so I have to reply in this edit. Anyway. "git commit" says to git: "move anything in the index (i.e. things which I have 'git add'ed, or which have been merged) into the local repository". "git add FILE && git commit" says "put FILE in the index and then commit the whole index to the local repository" "git commit FILE" says "assume the index is clear, and only commit FILE" to which git says the logical response, "sorry, dude, the index isn't clear, I can't do that" perhaps this will help: http://osteele.com/archives/2008/05/commit-policies

Something that you can run right in your browser (flash based): http://osteele.com/tools/reanimator/

Thanks for this! I recall reading over your article, http://osteele.com/sources/javascript/functional/, back in the day and being completely baffled and intrigued. These days I've been hacking with Clojure and wanting to bring some of that FP sanity back to my daily work ;)

Not really. There are better git tutorials out there - http://osteele.com/del.icio.us/osteele/git (from the article). Git allows you to choose which way you work more than (say) subversion. This article is an example of a slightly different way to work.

http://anarchaia.org/ http://blogs.azulsystems.com/cliff/ (JVM hacking, concurrency, non-blocking hashtable) http://osteele.com/ (javascript, functional programming) http://glinden.blogspot.com/ (personalization, collective intelligence) http://paulbuchheit.blogspot.com/ http://steve-yegge.blogspot.com/

I use the Google style guide as well since it's required by my job and while I have learned somethings from it I'm not a fan. 80 characters? I never had that limit for the 27 years of programming proceeding using the Google style guide and it never caused me any grief. I find that naming things descriptively and an 80 character limit are at odds. I'd rather read maxCombinedUniformVectors = maxFragmentUniformVectors + maxVectorUniformVectors; than maxCombinedUniformVectors = maxFragmentUniformVectors + maxVectorUniformVectors; or maxCombinedUniformVectors = maxFragmentUniformVectors + maxVectorUniformVectors; I admit it's kind of useful for side by side diff tools but in my previous 27 years of programming I never felt like "If only this code was 80 characters I could read the diff". More importantly though, the Google Style guide is written by Java programmers to try to make JavaScript into Java, totally ignoring all the benefits of treating JavaScript like JavaScript. That has it's benefits, especially for Java programmers. They don't have to learn some of the cooler things about JavaScript. They can go on treating it like a traditional oop language. And they get static type checking. On the other hand, all of these FP concepts are…

Thanks for all the good points. To be honest, I'm not sure what you're trying to say. I've been coding in python for years and Moka was built from my annoyance using functional paradigms with the stdlib. As you clearly showed, Python doesn't have an uniform syntax to deal with this paradigm. I.e. there are lots of different constructs and, as you said, common idioms or patterns. Have you already argued with a Java programmer saying that these 'Design Pattern' are just a limitation of the language.. whereas in Python you'd probably just use a simple Dict (or whatever)? I'm sure you did. I feel the same with the idioms and patterns. See, in Clojure (And Arc, and even Ruby), there is an uniform syntax.. whereas in Python we've got itertools, list comprehension, builtins map/filter, random builtins functino such as sorted(). I have to agree with you that Moka is not Pythonic in the There's only one way to solve a problem as we add a new way. However, Moka was created because there was so much inconsistent alternatives.. However, Moka is Pythonic in how it behaves. God knows I could have use all nifty hacks to make it behaves magically.. but I chose to take the explicit route by overriding list/dict. I could have used string interpolation for function (See http://osteele.com/sources/javascript/functional/); but instead went the Pythonic way with standard lambda functions. Maybe you are right about the operator keywords shortcut (i.e. using List().keep(operator.eg) instead of…

> require IDEs http://osteele.com/archives/2004/11/ides

There are both kinds of developers. I always thought Oliver Steele did a good job of explaining this here: http://osteele.com/archives/2004/11/ides Here's my take: The ability to write in a language that doesn't require excessive amounts of boilerplate code means I'm much more likely to refactor as the code evolves. Seeing an algorithm on one page, localizing and separating the logic cleanly with higher level constructs, easily translating the intuitions in my head to a coded solution, being able to dive into any part of the code without getting lost in the redundancy and residue of IDE vomit, etc... is all really valuable. Getters and setters that take up more than one very short annotation are eyesores, and the mere act of coughing them up into the code was never a bottleneck to programming speed no matter how bloated they get. The act of automatically renaming classes or variables, along with all the other code-shoveling refactoring support that IDEs provide is a miniscule subset of what refactoring is really about. The real refactoring work is done in your head. You need to look at the code and comprehend it in ways that aren't obvious, so that you can reorganize it to be simpler or maybe extendable. This kind of work cannot be done by an IDE; however, it can be aided by using a nice expressive language that gets to the point and doesn't distract you from the problem. When it comes down to building, deploying, and automation of other menial tasks, I'm not stuck with…

> auto-complete and instant doc lookup help you figure out what's available to call and what the various methods and classes do. That's also useful if you only use a particular library occasionally and just don't remember how it works. Lucky for me, I can have those things with languages like Perl and Ruby without having to resort to an IDE. > on a 500k+ codebase there are probably enough methods named "add" that just doing a text search is going to be pretty painful. The kind of tools you describe as being better than a text search are, in essence, just text search (and replace) tools. They're obviously much more powerful than the search and replace tools familiar to many MS Windows users thanks to the style of search functionality offered with editors like Notepad, Wordpad, and even MS Word -- but then again, so are the search tools available in a typical Unix environment, especially when using an editor like Vim or Emacs. > I think that there are other situations, primarily for working on larger projects but also for people new to the language or who use it less frequently, where the benefits of a really good IDE would still help out Ruby. I think that applies more for people who are used to an IDE approach to programming, really. The kind of development done with Ruby without an IDE near at hand actually uses a very different approach to development than an IDE-centric approach, and for someone used to that IDE-centric approach, having an IDE to help make the…

I had the older version bookmarked http://gskinner.com/RegExr/ which now redirects to this site. Some other good sites that I've used are: http://regviz.org/ https://regex101.com/ http://osteele.com/tools/rework/ http://www.rexv.org/ https://www.debuggex.com/