HNHacker News
TopNewBestAskShowJobs

austinz

2,359 karma · joined May 26, 2013

submissionscomments
austinz··on Count to ten when a plane goes down
This is very true, which begs the question - why was a 23-year-old summer intern placed in charge of the embassy computer system, or even given access to its central console? He may have have self-taught facility with computers, but I find it hard to believe he'd have much experience at that age with the sort of large, mission-critical institutional computer system described in the article.

I wonder if he had a supervisor sysadmin that he was working under, but given how he described his boss, that seems unlikely as well.

austinz··on Announcing The Fog Creek Fellowship
I just took a look at their 'About Us' page. It's basically "we're a software company, like startups, but we're better than those stupid startups because we're a real business". Sort of off-putting. I'm sure Fog Creek is a wonderful place to work, but when I visit an 'About Us' page, I want to read about your business, not a point-by-point comparison regarding all the ways you're better than some strawman caricature.
austinz··on I Don't Know Swift
The linked Twitter post does bring up a good point: I wish Apple would make it easier for third parties to build tooling for the iOS/OS X development environment. Stuff like alternative IDEs, Xcode plug-ins, tools for instrumentation/debugging, alternative simulators. Some of this already exists out there (e.g. AppCode), but most of it is really dependent upon the often-buggy first-party tooling. Better support for third-party tooling would ameliorate the pain developers feel when Xcode doesn't work well.

I don't even see any downsides. A thriving third-party tooling ecosystem would only serve to lure more developers, resulting in more applications and increased hardware and software revenue. It's not like Apple currently makes money selling its development software to developers.

austinz··on I Don't Know Swift
My recommendation is:

- Download the ebook that describes how to use the language. You can get it as an iBook or a PDF, or just view the documentation on the developer site. The ebook is really approachable and will show you how to do most things in the language.

- Learn a little bit about Foundation and UIKit so you can use the Cocoa APIs. You can build command-line applications in Swift without touching any of the Foundation stuff, but without it you won't be able to do that much.

- Go to Github and look at some of the projects people are doing. Check out their code for ideas as to what to do/what not to do, or how to solve problems that aren't discussed in the book.

austinz··on Programming is not math?
> Personally I have the impression that many web programmers, especially those who has never worked with anything other than the web, are ignorant of the existence of other branches of programming.

I see this again and again in the articles that show up here. Occasionally, mobile apps are acknowledged (although they usually mentioned when the author is trying to make a point about trivial social media apps).

> I have a feeling that most of complexity in web programming is incidental. It's a result of how poorly the web is designed as a platform. Of course it's very successful commercially but from a technical standpoint it isn't good.

It seems that most of the technical challenges that people run into in this field can be divided into two categories:

* Needing to accomplish something difficult by developing, implementing, or otherwise employing novel techniques, algorithms, data structures, automation, etc.

* Needing to hack around poorly designed or obsolete software, such as CSS hacks to get older versions of IE to render a page element correctly.

austinz··on The Most Terrifying Thought Experiment
The possibility of the Singularity coming to pass (as its boosters depict it) depends on the following being true:

1. Human-level intelligence is sufficient for creating an artificial intelligence that is superior to human-level intelligence.

2. The ease of a human-level intelligence or higher building a comparatively improved intelligence either: * Stays constant * Increases (becomes easier) * Does not decrease (become harder) to the point where further improvement is impossible before a Singularity-level intelligence is reached.

Neither of these two is a given, but I would wager the first is quite likely and the second is unlikely. As well, I would argue that it would not be unreasonable to argue that second is not a given, even if the first is true.

austinz··on Swift Blog
I did phrase that terribly. What I meant (and failed) to convey was that the most authoritative source of info on this topic was a post to a relatively obscure LLVM-related mailing list, rather than any sort of official announcement. However, I shouldn't have said "lack of transparency", because the devs could have chosen to not make any sort of public statement at all.
austinz··on Swift Blog
Their lack of transparency on this matter sucks, but at least they haven't committed to making it proprietary: http://lists.cs.uiuc.edu/pipermail/llvmdev/2014-June/073698....
austinz··on The New Haskell Homepage
I like the new site. It's beautiful and elegant. The weird flowers on the download page are gone. But the link to "Introduction to Functional Programming Using Haskell" takes me to the publisher page for the textbook "Aqueous Environmental Geochemistry".
austinz··on Swift Thinking [video]
Interesting that the Apple-provided sample app mentioned around 7 minutes in uses "~=" as a custom operator, given that it's already defined for use with pattern matching (match an input with some sort of pattern), and intended to be overloaded for that purpose. I wonder if this is just an oversight?
austinz··on Show HN: A Rogue State Along Two Rivers
I read this article the other day, and I really enjoyed both the presentation and the content. The historical and (especially) geographic context provided by the article is really helpful when it comes to trying to understand where ISIS came from, and how it could have taken over so much of Iraq so quickly.
austinz··on Show HN: A Rogue State Along Two Rivers
I assume that since "Jeremy Ashkenas" is listed as an author, and the submitter is "jashkenas", that this is a legit Show HN. Although, since it is a NYTimes.com article, it would be easy to assume otherwise at first glance.
austinz··on Sick of Ruby, dynamic typing, side effects, and object-oriented programming
I think a large part of good software design involves making the implicit into the explicit (although there are always tradeoffs).

Instead of writing six different very similar functions that implicitly do the same thing but on different types, we write a single function with generic type parameters. Instead of writing a bunch of nested for loops working on a bunch of mutable state in an imperative way, we use map, filter, reduce, fold, etc to explicitly describe the transformations we are trying to accomplish. Instead of allowing our code to crash when bad inputs cause an error, we use asserts to declare pre- and post-conditions. And so forth.

TDD style tests have their place, but they don't do all that much to make the implicit into the explicit. If you use tests as a source of truth or a form of documentation, you are essentially saying your specification doesn't actually exist except as some weird emergent phenomenon - and then you have to take the time to disentangle the assumptions inherent in the tests from the assumptions inherent in the choices of test inputs and outputs. Tests can, by their nature, only exercise an infinitesimally small fraction of the possible combinations of inputs and state transitions that your code can go through. So tests, which serve to validate the code, need themselves to be validated. How can we even arrive at the intuition that our tests are covering some useful sample of this gigantic state-space? Metrics like code coverage and the size of a test suite are only meaningful if you assume the tests themselves are sound in the first place.

austinz··on Dart Programming Language Specification [pdf]
What software engineering needs is more engineering discipline, and less stupid mystical bullshit.
austinz··on I/O Thoughts
Fine. Let's say that if you don't have HIDs or a monitor and you want a primary dev box, then it's not worth it. If you have the HIDs and monitor, are willing to do a little bit of third-party work, and want a machine that can competently serve beside whatever non-Apple machine you're currently using, then you can get started for far less than $2000. (I don't think this is a terribly uncommon use case, especially for people already developing for other platforms.) Would you say that is a fair assertion?
austinz··on I/O Thoughts
You can buy the Apple-branded stuff. Or you can buy a KVM switch, a SSD, and two sticks of RAM off Newegg yourself. Monoprice has HDMI to DVI converters for less than $3. Upgrading the internals is about as challenging as upgrading the internals of a non-Apple laptop. It's honestly not that hard.

On the off chance you don't have a mouse, a keyboard, or a display, you can get a decent mouse for around $5, a decent non-mechanical keyboard for $30, and a high-quality display for $150. All three of these will improve your productivity on your laptop if you're not traveling. If you don't have a laptop or a desktop...how are you developing for Android to begin with?

austinz··on I/O Thoughts
You can get a Mac Mini that more than suffices for around $600-$800. But honestly, if paying $2000 was the only way to get a set of Android SDKs and development tools of the same caliber as Apple's developer offerings, I would immediately do so. I like the idea of the platform and I believe in anything that makes it easier for developers to build better applications.
austinz··on ScalarArithmetic for Swift
Some developer decides to show a utility library they wrote for better interoperability between 32 and 64-bit numerical types to Hacker News and this is the reaction?

Right this very moment there's a REST library for Haskell on the front page, and Javascript libraries for various purposes show up on a semi-regular basis. Libraries, code, and frameworks for frivolous and serious purposes, for old and new languages alike, are constantly being posted to Hacker News. I honestly don't see how this is any different, except for this backlash to phantom hype which I find frankly quite puzzling.

austinz··on Sleep as a Competitive Advantage
"a person who is sleep deprived has no idea how functionally impaired he or she truly is. Most of us have forgotten what it really feels like to be awake."

I can attest to this. I went through a months-long phase where I got about four to five hours of sleep a night, mostly because I was going to bed around 4 or 5 AM. Only after I began going to bed at a more reasonable time and getting more sleep did I realize how much my mood had suffered and how much worse my ability to concentrate and solve problems had been.

austinz··on From India, Proof That a Trip to Mars Doesn’t Have to Break the Bank
I think it should be clear by now that a lot of people think that their expertise in software automatically qualifies them to make authoritative statements on behalf of every other field of science and engineering.
austinz··on Lisp CPU
It's funny, because in some cases you can write HDL code that looks like a loop - but in this context a loop instantiates multiple instances of some piece of logic.
austinz··on NodeBB: Node.js-based forum software
> EDIT: Also, when using infinite scroll, do not put anything in the page footer. Now when the pages have copyright info and couple links in there, I can see those only for a split of a second before new content appears. Makes me go crazy.

This sort of design element occurs way too often. I call them Tantalus footers, because they're always just out of reach. It also makes me wonder if the people who designed these things actually tried using them under real-life conditions.

austinz··on Inside the Mirrortocracy
That linked 42Floors blog post is terribly self-unaware.

> Most startups take the building of their culture very seriously, especially when the culture is still new and quite fragile.

If your culture is so fucking fragile that a guy wearing a suit (as opposed to a T-shirt and jeans) poses an existential threat to it, you need to re-evaluate whether you are actually building a company 'culture', or just some random agglomeration of the personality traits of the company's earliest employees.

> My friend Shawn just brought organic heirloom carrots and a 6-pack of Sightglass coffee to an interview as a gift. That’s awesome.

If I were a founder and you were a candidate who tried to bribe me like this, I'd politely show you the door. Why does the gift need to come before the interview? If it's a token of appreciation, why not after the acceptance or rejection? Are you hiring candidates based on their technical credentials, or their hipster credentials?

austinz··on The Safyness of Static Typing
The 2% figure doesn't take into account opportunity cost. Maybe a project written in a dynamic language has a well-engineered, comprehensive unit test suite that is large enough to cover for most type errors. Maybe that same project in a statically-typed language might not require so many unit tests - or maybe it might. Maybe developers working on the dynamic language version of the project spend more time reading through the code to understand how unfamiliar modules work - or maybe they don't. This sort of stuff is far more useful to know - and far more difficult to measure.

The 2% figure states little more than the fact that a project being developed by competent engineers can be debugged and tested to the point where the project becomes quite reliable and errors become rare, regardless of whether or not it is implemented using dynamic or static typing. I don't think any reasonable static typing advocate would try to argue that static typing is the only way to catch type errors.

The parser study is even less informative. It covers a project of very small scope using both a custom language (with a type system of very little expressive power) and a custom development environment, and does not take into account long-term maintainability or extensibility.

If you want evidence, keep on looking.

austinz··on Titan Aerial Daughtercraft
This is the sort of stuff I would love to work on, as an engineer. Amazing new applications of technology coupled with a truly meaningful purpose.
austinz··on Solar plant has generated “supercritical” steam
http://en.wikipedia.org/wiki/Supercritical_steam_generator has a helpful explanation and some links about supercriticality.
austinz··on Ask HN: If learning to develop for iOS- start with Obj C or Swift?
I would suggest going with Swift, but learning enough about Objective-C concepts to use the Cocoa APIs. There is a guide to interoperability between the two languages on the developer site.

For example, some sample code to call a method (here, one named 'upCommand') whenever the user swipes in the 'up' direction looks like this:

  let upSwipe = UISwipeGestureRecognizer(target: self, action: Selector("upCommand"))
  upSwipe.numberOfTouchesRequired = 1
  upSwipe.direction = UISwipeGestureRecognizerDirection.Up
  self.addGestureRecognizer(upSwipe)
A more idiomatic way in Swift to create a gesture recognizer might be to assign a closure to execute whenever the swipe is recognized.

However, because of the way Objective-C and Cocoa works, you need to define the target of the action as a string literal describing the method name, encapsulated in a 'Selector' object. This is a fundamental Objective-C feature that shows up as a common idiom in the Cocoa APIs. If you didn't know what a selector was, you might have trouble translating this API into working Swift code, since Swift has no real equivalent construct (except the 'Selector()' class described above, there only for backwards compatibility).

austinz··on Calling Back a Zombie Ship From the Graveyard of Space
Fascinating to see how originally the project was envisioned with new physical transmission hardware, but at a price that turned out to be impractical. However, software-defined radios enabled the project to be carried out for far less money, with only minor retrofits to Arecibo. I wonder what other applications are hiding out there.
austinz··on Your Job is Not to Code
Absolutely. I can't agree with this more.

A long time ago I worked on a codebase where (among other problems) developers who wanted to extend a particular feature needed to modify five or six different methods spread across a number of files. (This feature was basically a pipeline that took in JSON from our servers and translated it into views to display to the end user.) Forgetting to modify even one of these files would lead to code that compiled but would throw cryptic errors at runtime.

Developers from outside our team who wanted to work on the codebase and extend the feature would reliably lose several days to either the problem I described above, or hunting around the code trying to piece together how the feature worked from the disparate implementation details.

Eventually, I took some time off and refactored part of the feature so that only a single source of truth needed to be modified in order to extend it. As a bonus, this refactoring made the mapping between data models and views in our application explicit, making the behavior of the feature significantly easier to understand. I didn't ask management or submit any sort of formal proposal; I did this on my own time because I had become fed up with the limitations of the existing approach.

After the refactor entered the codebase, the aforementioned bugs vanished, as did many of the questions from outside developers about what models corresponded to which views, or how the feature worked, or how to extend the feature in general.

I tell this intentionally vague (and honestly quite pedestrian) anecdote not to brag (the refactor was reasonably straightforward), but rather because I wanted to emphasize the difference between feature work and technical-debt-payoff work. The refactor almost certainly saved a considerable amount of developer effort and increased code reliability. But how much so is not something that can be easily measured (if at all), unlike the impact of a user-facing feature. Not only this, some combination of apathy and political pressure from external stakeholders tends to lead management to deprioritize paying off technical debt. Proposals to management to formally set aside time to address other issues of similar scope were pushed back repeatedly or dropped.

PMs and product people can A/B test, gather analytics, get concrete data on hypothesis A versus hypothesis B when it comes to features. But it's rare that engineers get asked how much more quickly they could get their work done if they hadn't had to hack around unmaintainable hacks, or how much more reliable their code would be if bad design didn't muddy up the codebase or provide hiding spots for weird corner cases. Given how expensive software engineers are and how supposedly scarce they are, I'm honestly surprised that this isn't something management thinks about more.

austinz··on Troubled welds on the Bay Bridge
Responding to this from the parent comment (highlight is mine):

> Moreover, the fact that so many tax dollars were paid to a foreign company is offensive. Even if that company was at all competent, it shows a disregard for the American economy.

Competence is explicitly not the OP's point.

← PreviousPage 5 of 12Next →