ndanger.organism

We all know Windows is a ghetto (at least for developers); I just googled for confirmation. Unfortunately I’m stuck there because of work and have been using cygwin to make things easier.

Unfortunately I’m beginning to think cygwin is a ghetto too. You can compile some source, but there are enough differences to be annoying. Specifically you can’t compile libraries to link against other windows apps (like for Python & Haskell libraries) and the path wrangling & soft links break in any native app. It’s only nice if you don’t leave it’s confines.

So maybe a better analogy would be that cygwin is like having a really nice loft in a bad neighborhood.

In contrast MinGW seems more interested in making Windows habitable. Maybe it’s like bike paths & community gardens?

Anyone have any experience with MinGW? I think all I really need is the GCC tools, ssh and bash.

PS: and yes I’ve thought about VMware, etc. But I have to release under Windows anyway, so there’s no point having to maintain two environments. I do have an Ubuntu laptop but I never end up using it.

…in which all I want to do is read and write some goddamn ID3 tags.

I’ve said I want to learn Haskell but I’ve also talked about the pains of learning new programming environments (and given an example from Forth). So when I wanted to rename some mp3 files based on ID3 tags I thought “that’s a great excuse to use Haskell! What could possibly go wrong?” So I simply…

• install the Haskell Platform
• check Hackage for ID3 libraries
• cabal install taglib. FAIL: requires taglib_c C library
• download the Windows MSVC binary and copy to correct dirs under c:\cygwin\usr\local\
• update environmental variables according to the Cabal help pages. FAIL: still can’t find package
• use cabal install --verbose=3 taglib to find out it’s failing calling pkg-config
• remove MSVC binary of taglib_c
• try building taglib_c from SVN tip. FAIL: no configure
• try IDiii: cabal install idiii. FAIL: error installing encoding-0.6.2 dependency
• back to TagLib: download tarball & install. Success.
• add PKG_CONFIG_PATH='c:\cygwin\usr\local\lib\pkgconfig' to environment
• cabal install taglib. FAIL: the .pc files for taglib contain cygwin style paths
• rebuild taglib_c with --PREFIX=c:/cygwin/usr/local. Success: installed in same directory but with Windows style paths in the .pc files
• cabal install taglib. Success!
• run TagLib’s included test code (nice touch, btw). FAIL: can’t find DLL
• try renaming DLL’s & rerunning test. FAIL: finds DLL’s, can’t link. Suspect this is because GHC is built with MinGW
• uninstall source-built taglib
• install taglib’s MinGW binaries, including copying & modifying source built .pc files
• cabal install --verbose=3 --reinstall taglib
• re-run test code. FAIL: can’t link because of duplicate symbols in bytestring. WTF?
• test in ghci. FAIL: can’t find DLL
• rename DLL’s… FAIL: can’t link to DLL
• uninstall MinGW taglib
• try MSVC taglib once more for fun. FAIL: can’t find/link to DLL’s

So I’ve got no ID3 library a broken GHC installation. Next stop: mailing list. But first…

Let’s try that in Python

I wish I could say it was sooo much easier in Python, because that would mean I was done. Instead…

• check PyPI for ID3
• pip install -v PyID3. FAIL: can’t resolve URL’s
• follow URL from PyPI. FAIL: Django error
• skip pyid3tag because of external dependencies
• pip install id3reader. Success!

A few dozen lines of code and a few Unicode issues later and I am automatically renaming files based on ID3 tag.

Unfortunately the next step is automatically tagging files based on filename and id3reader doesn’t write tags. This is why people write their own libraries.

So what’s the point

Nothing really. I just wanted to complain. Also people often ask me what it’s like to be a programmer. Sometimes, this is it. My advice: stay in business school.

4 and a half months later, the thrilling conclusion.

2008-09-25 (Thursday) – 2008-09-27 (Saturday)

Oh right, I came here for a reason. Both DEFUN & CUFP were good. The functional community seems really nice (and smart). Basically everything else I said a year ago.

Then on the walk back I saw the Pandora draw bridge in action. Score!

2008-09-28 (Sunday)

Then I flew home. The End

(A comment gone long, I decided to turn this into its own post)

The reality, though, is that we all do polyglot programming all the time. We use command line scripting languages to simplify our lives, and build languages to manage repetitious build processes. In the sphere of web development, we’re regularly working with regular expressions, JavaScript, and declarative languages like XML, CSS, and SQL (or its derivative, HQL). It’s exceedingly common to see jobs looking for developers who can write both an ActionScript front-end and a JVM back-end (Grails, Roo, whatever). I worked at a shop where we used perl for file processing and fed those into a database, just to be consumed by Java batch process. One gig had service calls from Java to .NET in order to interoperate with Microsoft Office products. In none of these cases did the architects sit around and go, “Oh, man, we can’t implement that solution: people are just too stupid to handle it.”

Robert Fischer, We Aren’t Too Stupid for Polyglot Programming

I think Robert’s absolutely right in that we use many languages all the time, the questions are 1) why and 2) is it the right thing to do.

In my experience, polyglotism falls into a few patterns:

1. Low level + scripting language driver (C + Lua)
2. Frontend + Backend (Web)
3. Core product + automation (Make, perl)
4. Well establish DSL + general language (SQL, regexps)

In all cases polyglotism provides some obvious benefit. For the first two, that benefit is that it allows the project to work. If Lua were fast enough and Ruby ran in the browser… For #3: mixed language automation is an artifact of low-level languages. Make is a good build tool for C but Ruby’s build tool is Ruby (Rake). Given a change in technology and the right language, these could all be monoglot.

In the last case the DSL’s are chosen for convienence: SQL is better than hand B-tree manipulation and regexps better than FSA’s.

Using multiple languages isn’t without cost. An obvious one is that learning languages is hard. Most developers know SQL but how many are good at tuning queries? Knowing a language also isn’t the same as fluency. Until you’re fluent in both languages, you’re likely to favor one. See the object/relational–not to mention FP/OOP–divide for examples.

There’s also the technical costs in translating data. XML, Protocol Buffers, Thrift, etc. are all valid interchange formats, but they’re not free. Robert’s emphasis on JVM languages does ease this hurdle, since I believe all the JVM languages can pass objects.

Finally there’s the cost of tools & debugging. You now need tooling–compilers, debuggers, syntax-aware editors–for several languages. More languages can lead to more complexity. Making matters worse, error messages across language boundaries are often cryptic, even when both languages are on the JVM.

So should we all be polyglot? As a matter of personal improvement, I’m all for learning new languages & techniques. But in terms of actually writing good software quickly, it probably only applies if

• There’s obvious, quick benefit
• There’s a clear separation
• None of the other costs are too high

Personally, I think the big efficiency gains are in monoglot solutions. In the web world, glot-supremicists–i.e. Lisp and Smalltalk–have come up with some interesting web frameworks. Polyglotism is a fallback when abstractions leak.

Like many dilemmas, this one results from either/or thinking. A third alternative is to try both methods in parallel and just use whichever result arrives first.

Conal Elliott, Simply efficient functional reactivity [PDF]

Peter Van Roy’s excellent Programming Paradigms for Dummies: What Every Programmer Should Know [PDF] lead me to reread–or I suppose “read instead of just skim”–Conal Elliott’s 2008 FRP paper. It’s interesting, but a little too wrapped up in Haskell type insanity for me understand deeply. I did like the above quote though, it’s such a simple reminder that multicore is changing programming.

Speaking of changing programming, Optical information processing in
Bose–Einstein condensates [PDF] is a great paper by Dr. Lene Vestergaard Hau. You may remember Dr. Hau from 1999 when she slowed light to 38 mph and from 2007 when she transformed light into matter and back again. Smart cookie, that one.

She’s got more papers on her lab web page.

Feel free to email me if you’ve got questions.

The Opportunity

Precision Therapeutics, Inc. (Precision) is an applied sciences medical laboratory located on the South Side of Pittsburgh. Precision assists oncologists in choosing effective cancer therapies for cancer patients. We are currently seeking a Software Test Engineer to join the Precision team.

Duties & Responsibilities

Precision is seeking a highly motivated person to fill the Software Test Engineer position. The successful candidate for the position will join a talented team of ‘A player’ technology and biology professionals in the development of hardware and software systems designed to personalize cancer therapy treatment on an individualized patient basis.

This position is within the Technology Development Department and will report to the Software Release Manager. The successful candidate will maintain and monitor verification and validation activities within the Technology Development Department. The scope of position includes verification and some validation of all software applications and automation hardware that support other corporate departments, including: the clinical laboratory, records management, clinical trials, customer service, billing, sales, and accounting.

The responsibilities of the Software Test Engineer will include working with developers and users to verify and validate software requirements, assess risk, enforce change control, assist and monitor the creation of test plans and test cases, create automated test scripts, and execute test cases during phased releases. The position will be empowered to reject deployment of any software change that has not completed the change control process.
Specific duties include: Requirement reviews and validation, change control, risk assessment, documentation reviews, test case authoring, unit, integration, and system verification, code reviews, occasional test team leadership, and providing daily/weekly test status data to management for corporate project tracking.

If you are seeking a dynamic, challenging atmosphere, which is never boring, and a chance to make a difference and help cancer patients, email your resume to PTIResumes@ptilabs.com with the words Software Test Engineer in the subject of the email.

Qualifications

Education

• Bachelor’s degree in computer science, engineering, or a related discipline. Master’s degree preferred

Experience

• 3+ years Software Testing experience in a process-driven, web-based software development environment (Agile or risk-based preferred.)
• 2+ years experience as a test case author and manual tester
• 2+ years experience assessing requirements and technical specifications for completeness and accuracy
• 1+ year(s) in a team leadership role mentoring new test team members
• Served as a Test Engineer on one or more projects throughout the entire software lifecycle.

Required Skills

• Excellent organization skills
• Excellent writing skills with exceptional typing speed
• Ability to rapidly document detailed test cases that are traced to functional requirements and engineering specifications
• Ability to identify configurability and undocumented features for high-risk test opportunities
• Ability to identify gaps in requirements, specifications, and documented test cases
• Experience maintaining test documentation and traceability to changes in requirements and technical specifications.
• Experience with documenting project Test plans and exit/acceptance criteria
• Experience with manual test case execution techniques.
• Experience evaluating risk associated with application changes
• Ability to adapt to priorities that change frequently
• Ability to justify the categorization of test cases. (Acceptance, Regression, Feature)
• “Get it done!” attitude that strives to uphold commitments and stay on schedule
• Working experience in a software development environment with formal software quality processes conforming to ISO, IEEE, or FDA QSR standards and guidelines
• Understanding of web based application architecture and OOP concepts, specifically Java, Struts, JavaScript™, and HTML
• Ability to trace data throughput using Oracle SQL queries and xml parsing tools
• Experience writing automation scripts with Selenium IDE, Perl, or Python.
• Familiar with Eclipse development environment, source control, and ANT targets
• Ability to effectively describe anomalies in sufficient detail to reproduce the behavior
• Ability to work independently or in small teams
• Well developed and effective oral and written communication and interpersonal skills
• Ability to effectively communicate technical concepts with non-technical end users
• Proficiency with Microsoft® Office, Project, and Visio

Preferred Skills

• Team leadership experience
• Experience with process control and/or data acquisition
• Knowledge of statistics and numerical methods
• Experience with database design, development, and optimization

…Are you assuming malice or incompetence where none might exist?

Chris Winters, Bitter Discourse Indeed

Occasionally, and often related to language wars or Zed Shaw, the internet realizes that there is a stunning lack of online decency. A backlash occurs. In one of these exchanges I read a blog post–the source of which I’ve unfortunately forgotten–that crystallized my opinion: practice the principle of charity.

PS: Speaking of bitter discourse and moral codes, I highly recommend Doubt.

Because if it’s YOU who dies, smashed to death on the iceberg by your skunkweed-stoned ship captain, you’re going to be REALLY pissed off. I guarantee it.

Steve Yegge, Have you ever legalized marijuana?

The tl;dr crowd might summarize Steve Yegge’s latest article as “it’s harder than you think.” But that would miss the entertainment of Steve’ writing (see above). It would also miss the comments which, while not perfect, are good enough to summarize my opinion:

• Important things still need done
• Necessary complexity != accidental complexity

So yeah. Things are more complicated than you think. But if they’re important you figure it out and do what’s necessary.

And it’s obvious but bears repeating: the law != code.

Price & quality aside, an advantage of open source software is network effect: the more people are using a piece of software, the better the chance someone else has the same problem as you (and hopefully the sooner you’ll have the same solution as them). Not that open source itself causes the network effect, rather it’s the arms control treaty that allows competitors to contribute to shared code. So this New York Times’ article on Hadoop made me wonder how Google’s closed source infrastructure will play out.

Using closed source makes sense if the code would help competitors more than they would contribute back. Given that Hadoop was inspired by Google’s MapReduce paper ^[1] it seems like that was originally the case. But, to the article’s main point, Hadoop is now used by Yahoo, Microsoft, Facebook, Autodesk, numerous startups, etc… which is to say at least a few smart people. If you believe in the power of open source, this eats away at Google’s proprietary advantage.

Google could, of course, switch to Hadoop, either fully or via an in-house version (whose changes don’t have to be re-released since they’re not selling the software). Both require a cost, either up front or in ongoing merging. Alternately, they could simply adopt any ideas that seem worthwhile; at scale the coding cost is probably small compared to 1) developing the idea (necessary for any change) and 2) maintenance. According to the article, Google and IBM are are financing college-level Hadoop classes, so Google at least wants students to graduate understanding MapReduce theory and/or parallelism.

On an unrelated note, check out that photo at the top of the story. Was the guy on the right badly photo-shopped in or does he just not cast a shadow?

…er, actually that’s probably just me. My work laptop runs Windows for unfortunate corporate reasons. Cygwin staunches the bleeding, but the Cygwin build of Python has trouble with some packages (e.g. matplotlib and pymssql). So I’m running the cygwin shell but a Windows build of Python.

PyX–cool looking plotting/graphics tool–makes a subprocess call to kpsewhich to find files. The cygwin build of kpsewhich naturally returns a cygwin path; the windows build of python naturally chokes. As a hack, I edited /Python25/Lib/site-packages/pyx/pykpathsea/__init__.py to add a call to cygpath -w. I also replaced the os.popen calls with subprocess.Popen since os.popen 1) wasn’t working for me and 2) is deprecated.

The modified function:

    def find_file(filename, kpse_file_format):
        # 2009-01-08: DAG: edits to allow working with cygwin tex but windows
        # python.  Replaced os.popen with subprocess.Popen and added call to
        # "cygpath -w"
        command = 'kpsewhich --format="%s" %s' % (kpse_file_format, filename)
        if not find_file_cache.has_key(command):
            path = Popen(command, stdout=PIPE).communicate()[0].strip()
            if path:
                path = Popen('cygpath -w %s' % path, stdout=PIPE).communicate()[0].strip()
            find_file_cache[command] = path
        return find_file_cache[command]

The patch: pyx_cygwin.diff

The full file (zipped w/ path relative to Python25/Lib): pyx_cygwin.zip

Enjoy!

Conservative logic is a comprehensive model of computation which explicitly reflects a number of fundamental principles of physics…

Edward Fredkin and Tommaso Toffoli, Conservative Logic p. 1

Axioms for computation that are based on noninvertible primitives can only reflect aspects of macroscopic physics. While they offer enough expressive power for dealing in a formal way with what can eventually be computed by any physical means, they may deprive us of essential tools for discussing how best to compute in particular, whether and how the kT barrier can be overcome-since many relevant aspects of microscopic physics are totally out of their reach. To remedy these eficiencies, the axioms of computation must be told some of the “facts of life” of the microscopic world. This is one of the goals of conservative logic.

Edward Fredkin and Tommaso Toffoli, Conservative Logic p. 3

Via the LtU Inspiring papers thread comes Fredkin and Toffoli’s 2001 paper: Conservative Logic [PDF] (local cache since I couldn’t find an official site with a download; thanks to Strange Paths for having a copy of the PDF). The paper 1) presents a model of computation based on physics-inspired axioms, 2) demonstrates that the model is computationally universal and then 3) gives an example implemented using billiard balls. Well, technically perfectly elastic collisions of spherical bodies constrained to a 2-dimensional plane, but still fun.

It reminded me of Neil Gershenfeld’s Programming Bits and Atoms talk. Specifically both changed my concepts of computation: Gershenfeld shows a bunch of examples of asynchronous logic automata (sorry for the crap link to a google index, I haven’t read enough to find a good reference; let me know if you find one) and also demonstrates physical logic gates built from plastic tubing and air bubbles. Given that Toffoli was cranking out papers in the late 70’s, I wouldn’t be surprised if Gershenfeld draws from his work.

Beyond the cool factor, both works have practical outcomes. Gershenfeld shows proof of concepts like the “paintable computer”: a computational surface that runs a Postscript interpreter. He also demonstrates a(nother) linear-time sorting algorithm that depends on the ALA property that transmission is also storage (cells store values, transmission is merely the passing of values down a chain of cells). Fredkin and Toffoli make no such claims, but since a primitive of Conservative Logic is the unit wire–an element that both stores and transmits a value–the same should hold.

Fredkin and Toffoli’s emphasis on conservative physics principles leads to another huge benefit: “The central result of conservative logic is that it is ideally possible to build sequential circuits with zero internal power dissipation.” Nice.

But, really, my interest is in the combination of computer nerdery with physics nerdery (I spent years doing integrals studying physics). This is the stuff inspires me when I feel like a programming career is nothing more than CRUD web interfaces; you might even say reading these papers prevents my architecture from sucking.

In a similar vein, I recommend The Feynman Lectures on Computation and Scott Aaronson’s blog. Aaronson’s blog is a cornucopia of technical things I don’t fully understand, including one of my favorite blog posts of 2008: Time: Different from space.

While working on my goof-off POTM, I needed to add a function to an already instantiated object.

The obvious thing almost works:

>>> class MyClass(object): foo = lambda self: "Foo"
...
>>> myobj = MyClass()
>>> hasattr(myobj, 'bar')
False
>>> myobj.bar = lambda self: "Bar"
>>> hasattr(myobj, 'bar')
True
>>> myobj.bar()
Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
TypeError: <lambda>() takes exactly 1 argument (0 given)

Here’s the problem:

>>> type(myobj.foo)
<type 'instancemethod'>
>>> type(myobj.bar)
<type 'function'>

Our dynamically added bar is a regular function so the self-injection magic isn’t happening.

It turns out that the magic is actually just descriptors. As Bruno Desthuilliers points out you can manually activate the descriptor machinery:

>>> myobj.bar = (lambda self: "Bar").__get__(myobj)
>>> type(myobj.bar)
<type 'instancemethod'>
>>> myobj.bar()
'Bar'

For those who are more semantically inclined, you could instead use the (deprecated) new module:

>>> from new import instancemethod
>>> myobj2 = MyClass()
>>> myobj2.bar = instancemethod(lambda self: "Bar", myobj2)
>>> myobj2.bar()
'Bar'

And if you want your semantics without the deprecation, use types:

>>> from types import MethodType
>>> myobj3 = MyClass()
>>> myobj3.bar = MethodType(lambda self: "Bar", myobj3)
>>> myobj3.bar()
'Bar'

“Easy as cake!”

On Daniel Burka’s recommendation (at MeshU) I checked-out a copy of How Buildings Learn from the Carnegie. Summary: RECOMMENDED.

In the book, Stewart Brand–of Whole Earth Catalog fame–looks at the evolution of buildings, a subject he claims is sorely under-researched. He first establishes his framework, the six S’s: site, structure, skin, services, space Plan, and stuff; and then outlines the major archetypes of buildings: high-road (cathedral), low-road (warehouse), and hollow-souled sell-out architectural-digest pornography (most everything else, incidentally it was the high-road/low-road distinction that Burka used in his talk), Next he descends into detail. Finally he provides some hints for designing for change. And then, for emphasis, he re-states everything in the appendix and ends with a final plea for everyone to start paying attention to how things change in the long term, damnit.

Like anyone who’s learned software patterns, I know of the Christopher Alexander classic. But I put it off in favor of reading books about, well, software. How Buildings Learn frequently references Alexander’s works. It also shares a lot with software design: Brand advocates less up-front design, direct client involvement, choosing processes and artifacts that provide feedback and “short” iterations with rapid deliverables–basically Agile. (He also advocates spending time & money on a solid foundation and “documentation”: he lauds John Abrams “as-built” photo documentation. These could be interpreted as “anti-agile”, but as James Shore points out agile is no excuse for irresponsibility.) Unlike books on Agile software, How Buildings Learn benefits from being about something tangible: buildings. I spent my freshmen year in the University of Pittsburgh’s Litchfield Towers (picture above) and I currently work in a new office building that has the perfect triumvirate of leaky roof, non-function HVAC and architectural awards. It was easy to understand Brand’s examples. It took me much longer to actually understand–not just parrot–Agile. Such is the power of metaphor.

So recommended. Even if you’re not a programmer.

The end of CUFP 2008 was an open discussion that focused on–surprise surprise!–how to take functional languages mainstream. The future looks pretty bright to me: as Don Syme pointed out Microsoft is serious about F# and–although it got no love at ICFP–Clojure provides a functional escape for the JVM bound.

Of course availability is not enough: people also need a reason to switch. Many people brought up the “killer app”, the functional programming Rails. One functional language already has one: Erlang. Instead of db-backed webapps, Erlang makes it “easy” to create massive backends (hee hee). Francesco Cesarini, Nick Gerakines & Mark Zweifel (slides [PDF]) and Bob Ippolito (slides) all had commercial examples. Of course process oriented concurrency, no shared state and the OTP aren’t exactly an app… maybe “killer underlying philosophy and toolkit”?

Most other commercial users were either financial quants or small startups looking for their Paul Graham advantage (see the list of abstracts). All emphasized the enhanced productivity of functional programming. The quants were an interesting case. They are small groups within huge–and conservative–companies. Functional programming snuck-in around the edges. And once you have working code…

Hence the subtitular question: why did people start using Python? I don’t know of any killer Python apps. It’s just easy to code yet feels “solid”: it’s got unit testing frameworks, test coverage tools, documentation extractors, a REPL, a package manager, etc. Knowing that smart developers are writing tools for Python is pretty reassuring. (So is having Guido work for Google.)

Haskell feels solid. GHC is easy to install and comes with an interpreter (though not quite a REPL, which still bothers me). Hackage and cabal-install handle package distribution. And there are enough developer tools: QuickCheck, HUnit, HPC, Haddock, etc. It even has an Emacs mode.

All that is to say that from my “I work for a small group within a small company and can get away with a lot” point of view, Haskell is ready. All I have to do now is decide if it’s easy… and then produce some working code.

This thread tangentially brought up the fact that Python doesn’t automatically generate __ne__ (called by !=) from __eq__ (==).

Madness ensued.

In a libertarian spirit, I hacked out a class decorator to add rich comparison methods. Then I forgot all about it. Then I was bored on a plane flying back from Victoria. Now I present to you…

PyComparable

PyComparable is a Python package to add rich comparison methods to a class. The name is based on Ruby’s Comparable mixin, though it turns out to be a bad name. Ruby’s Comparable defines rich comparisons based on the <=> method, something Python already does. PyComparable is instead intended for when you have some rich comparison methods and want to generate the rest. (Of course, this hardly ever happens which is why you will probably never ever need PyComparable. Oh well.)

It’s also not really meant to be used as a mixin (though I provide ComparableMixin and ComparableMetaclass for your pleasure). Instead it’s a designed for future use as a class decorator: the comparable function takes a class as an argument, adds the methods, and returns a new class.

You can get more details in the README.

PS: It looks like this was done back in January 2007. Unfortunately, the link was dead.

PPS:

There’s also an ActiveState recipe that takes a slightly different approach. It assumes the objects being compared are “reflective” (I doubt that’s technically correct): it relies on reversing the operands. The upshot is that it only requires you to implement one comparison method. PyComparable requires two comparison methods, but never calls a method of the right hand side operand.

Oh, and there’s the fact that neither will work in Python 2.6 or 3. Doh!

I was getting ready to blog a bit about attending DFUN and CUFP–both co-located with ICFP–and noticed I had this draft sitting around. I was hoping to send it out as a “ha ha, look how hard it was to build Chromium, but now it’s working!”

But now, it’s a “ha ha building Chromium was so hard, er… I failed!”

So folllow along won’t you on my trip to FAIL…

• Following Google’s Win32 build instructions, download Google’s depot tools [ZIP] & install in C:\depot_tools (blah)
• Follow directions to get version of source
• Download & install Visual Studios Express 2005 (C++)
• Download & install Visual studios service pack 1
• Download & install Microsoft SDK for Vista
• Run Start Menu -> Microsoft Windows SDK -> Visual Studios Integration
• Download & install Microsoft SDK for Server 2003 (to get ATL; Server 2008 won’t run on Express 2005)
• Run Start Menu -> Microsoft Windows SDK for Windows 2003 R2 -> Visual Studios Integration (since order of integration may matter)
• Since the above didn’t work, add paths as per this help forum thead
• Also add C:\Program Files\Microsoft Platform SDK for Windows Server 2003 R2\Include\atl
• Disable exception config as per this thread
• Re-order includes as per this thread
• Make WTL changes (hey, why not) as in this this post
• Ask work for a full-blown copy of VS2005. Get handed a copy of VS2003.
• Go back and get a stack of MSDN discs. Find out it’s got the MSDN libary, SQL Server developer edition and… a bunch of little utilities
• Throw up your hands and fly to Victoria for a week of hiking and 3 days of functional programming immersion. Ahhh…

If you are interested in building Win32 Chromium with free tools you might want to follow this thread on building Chromium with Visual Studios 2005 Express. I assume someday it will work.

Since waxing poetically about chrome, I’ve hit a few more snags. So now… THE BACKLASH!

A futile search

“Find in page” doesn’t search text I entered! So when I’m, say, editing my Wordpress posts, I can’t search within the edit box. I know, I know another reason to actually get APP working…

This turns out to be a known bug with WebKit: Bug #269

The problems with bookmark keywords

I loved Firefox’s bookmark keywords. If you’re not familiar, you basically assign a keyboard shortcut for a bookmark. For instance I assigned “rlike” to the Reddit upvote bookmarklet so I could vote without touching the mouse (well, mouse nub on the Thinkpad). It’s Ubiquity lite.

Chrome separates bookmarks (static, no keywords) from “Search Engines”, which seems like a strange design decision. I’d prefer them to be integrated or to at least allow the magic Omnibox to search through your local bookmarks. It is the Omnibox after all.

Adding search engines also has some problems. Primarily, { isn’t allowed, which pretty much kills javascript bookmarklets. The second is a minor UI issue: there’s no quick visual feedback for failed input. Hence:

• Bug 2238: Add search engine dialog doesn’t allow “{” (open curly brace); can interfere with javascript
• Bug 2239: Add Search Engine dialog: green checkmark icons indicate success even for failed input

Well do something about it

Turns out Chromium doesn’t build under Visual Studios Express, but that’s an ordeal for another post.

When I first looked at Forth I thought “neat, but where’s the virtual?” or how can old code call new code. Turns out that Leo Brodie’s Thinking in Forth has the answer: DOER/MAKE. Basically DOER creates a placeholder word and MAKE rebinds the definition. All via the magic of the explicitly controlled return stack.

Unfortunately this has the same drawback as C++’s virtual: dynamic code has to be explicitly declared.

In other Forth news

Looks like there’s a freeware version of VFX Forth available. Link via this Dr. Dobb’s article on Modern Forth.

It’s official!

HTTP_USER_AGENT:Mozilla/5.0 (Windows; U; Windows NT 5.1; en-US)
  AppleWebKit/525.13 (KHTML, like Gecko) Chrome/0.2.149.29 Safari/525.13

What’s to like

Most obviously: it’s fast. Javascript is super responsive; Gmail feels like a desktop app–unsurprising given Google’s design goals. The browser itself is pretty quick too. I didn’t bother running any half-assed benchmarks, but opening & switching tabs is noticeably faster than Firefox. (Which, as an aside, serves as a nice reminder that planning for performance isn’t the same as prematurely optimizing. Performance matters.)

Speaking of tabs, Google makes a big deal about Chrome being designed around the tab. I don’t really get much use out of the new-tab page but the ability to drag tabs out of a window is nice. Firefox let’s you drag tabs back and forth, but you have to manually create the window first. Firefox also doesn’t show you a cool thumbnail of the tab contents while dragging. Simple, but very useful.

The only time I open new windows manually is via Ctrl-Shift-N: incognito mode. I’m sure this will be useful for the politically repressed, but mostly I spend time on Persian Kitty.

Speaking of porn, looking at high-resolution web-design porn is nice thanks to the minimal interface. Despite the gimmicky sound of “we wanted to reduce the ‘Chrome’ of Google Chrome”
(link) there really is less clutter:

It’s also got some features that make browsing easier, like drag and drop file uploading and font scaling. The font scaling isn’t as good as Firefox: it doesn’t have the new Cairo-backed Firefox image rescaling so scaling distorts pages. Similarly Chrome’s drag and drop uploading can’t handle multiple files like dragdropupload (though, to be fair, that’s a plug-in). Last but not least, Chrome’s got resizeable text-areas. Amazing!

For the developers, Chrome’s view source has line numbers and live links that open in a new tab. It’s also got a built-in DOM inspector.

Oh, and, despite the pile of bugs it doesn’t crash.

Ok, what’s not to like

The missing functionality: ChatZilla, DownThemAll, Multiproxy Switch, Tabs Menu, etc.

The placement of new tabs can be a bit strange. Ctrl-T tabs go to the end. When clicking links from a tab, they open directly to the right of the current tab. If you click a bunch from the current tab, they open left to right. But something–not sure if it’s scrolling the page or changing focus or what–resets the order. So you open a bunch of tabs in order. Then a bunch more get prepended to that list. Definitely not a show-stopper.

And… the ugly?

Chrome is beautiful. It’s got the same well-designed simplicity of other Google products or anything from Apple (at least from what I’ve seen tangentially, I’ve got a $25 MP3 player, a Samsung cell phone and a Thinkpad). And it’s open source (WebKit plus Google’s own V8 javascript engine) so you don’t feel immoral using it.

But… but… it’s got no plugins.

A long time ago I was a devoted Opera user. I even paid for it! I didn’t switch to Firefox until there were plugins for better tab management and gestures. True, I could have flexed some open-source muscle and just changed Firefox’s source code…

Yeah, right.

Firefox managed to produce a tinkerer culture. Can Chrome do the same? Of course, I’m assuming a tinkerer culture is good. Maybe “closed & beautiful” is better.

Then there’s Ubiquity. If you missed the mini-buzz before Chrome stole it’s glory,Ubiquity is a Firefox plugin that let’s you script web tasks via Javascript scripting. It’s bookmarklets on steroids. Watch the video, it’s kind of awesome. I had more to say about it, but Mr. Jackson says it better.

Finally I’ve seen some comments about Chrome sniping Mozilla’s marketshare. I’m sure that’s a minority opinion, but it’s still a ridiculous one. Chrome is innovative. Putting that innovation in a brand new product instead of pushing it into Firefox is a design decision, not an attack. Time will tell if it was the right one.

In the meantime the release of Chrome has at least got people talking about the browser, which is a good thing and, incidently, one of Google’s goals.

Download it yourself

Oh yeah, I guess a link would be nice: Chrome

PS

I thought I’d try out a gratuitous use of highlighter to see if it makes the blog more scannable. Let me know!

Paul Graham doesn’t think you were meant to have a boss (and the Cliff’s notes in case you thought he was saying you suck). I don’t agree with the “lions and hunter-gather tribes didn’t have bosses” arguments–most hunter-gatherer’s weren’t very good programmers either–but I do agree that large companies are a bad place to work.

My worst job was a summer internship at FedEx. There were several superficial problems, mostly I was under 21 & car-less. Which is to say that I had nowhere to go and no way to get there. It was also the summer–in Memphis–so the heat and humidity were both in the (Americocentric) 90’s. And I had to wear khakis and polo shirts everyday. Normally I only wear polo shirts to weddings.

But the main problem was the job itself. Beyond a general choice (i.e. “technical, not business”), placement was up to the internship coordinators; I ended up in the group that fixed wide-area networking problems. There were no problems. Except for the occasional cable pull, I made network diagrams in Visio and read about 7-layer networking.

“Well,” you might say “that’s not because FedEx is big,” but you’d be wrong. Having free-time is a big company phenomenon. I’ve never been a founder, but I have trouble imaging them sitting around twiddling their thumbs. (I do have experience running one-time bike events and even something that small doesn’t leave much time for sitting.)

If you’re still not convinced it was a big company problem, the Network diagrams were needed for ISO certification. And I never saw the engineer I reported to use their computer for anything other than Solitaire–Windows Solitaire. Just try to imagine founders turning to each other and saying “I’m bored… why don’t I work on getting ISO certified?” “Great idea! You do that while I play some Solitaire.” (Sounds of mouse clicking. A single gun-shot comes from the direction of the angel investor)