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.
2,359 karma · joined May 26, 2013
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.
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.
- 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.
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.
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.
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.
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?
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.
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.
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.
> 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?
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.
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).
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.
> 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.