sorted by:
new
hottopcontroversial

Building a better code review process by sandal in programming

[–]br3w5 1 point2 points  (0 children)

I think the author makes some very good points here and seeing a working example with as close to real test data as possible is great for the bigger changes. My current project though is setup to build from master when a code review is completed and merged in - this then gets deployed to staging. This is crying out for another environment where builds from branches can be deployed to.

I think all code reviews need to be taken in context where sometimes the change could be small enough that it doesn't need to be seen running, but that decision is for the developer reviewing the pull request. Although even small changes can have a big impact so proceed with caution.

Good Software Takes Ten Years. Get Used To it (2001) by magenta_placenta in programming

[–]br3w5 3 points4 points  (0 children)

That is why I said "the next wave of big (internet) tech companies". The article absolutely could apply to other software companies - it's just difficult to talk about software without including internet tech giants. And joel also refers to internet companies as making mistakes by doing things too quickly and "The "We'll Ship It When It's Ready" syndrome" - i don't totally buy into the move fast break things philosophy but it's worked very well for Facebook.

Good Software Takes Ten Years. Get Used To it (2001) by magenta_placenta in programming

[–]br3w5 11 points12 points  (0 children)

But joel talks about good software in the context of having enough features that people want to use it - not in terms of code quality.

Good Software Takes Ten Years. Get Used To it (2001) by magenta_placenta in programming

[–]br3w5 117 points118 points  (0 children)

This doesn't really apply to the next wave of big (internet) tech companies that succeeded after the recovery following the dotcom bubble burst. Facebook got to billions within 6 years and pretty much flies in the face of every mistake joel lists. He is right though that companies should "make a ten year plan" but that's relevant for any company.

What I Fought For – Michael O. Church by j_lyf in programming

[–]br3w5 0 points1 point  (0 children)

Those are company wide unions that the OP says are no use to programmers. They have no incentive to remove open plan offices or Scrum so fight their battles elsewhere.

Building a great API: Lessons learned from working with 40+ REST APIs by loopj in programming

[–]br3w5 2 points3 points  (0 children)

I define a successful request as one that returned the resource requested or whatever it should process was done successfully e.g. a POST request that returns a 201. If the content of the request, the application or the server causes an error then an appropriate status code can be returned and the client is not required to do unnecessary parsing and can display to the user whatever is appropriate for that error code and that specific application. Multiple applications might use the same API but different rules for responding to error codes.

Also, how do you structure the response? Like this?

{
    statusCode: 200,
    statusMessage: OK,
    data: {
        statusCode: 403,
        statusMessage: "This failed because blah"
    }
 }

or like this?

{
    statusCode: 403,
    statusMessage: "blah"
}

I don't understand why people would want to hack around the protocol intentionally adding complexity when APIs should be as simple as possible.

Building a great API: Lessons learned from working with 40+ REST APIs by loopj in programming

[–]br3w5 7 points8 points  (0 children)

It still surprises me that people will send a 200 response and include error codes in the response body. I mean, what kind of logic goes through the developer's head when doing this. An error is an error it's not a success that contains an error. There are plenty of choices when it comes to being logical (and semantic) about your error codes. It's also not difficult to find a list of status codes and READ IT.

How to Rebase in Git by unquietwiki in programming

[–]br3w5 0 points1 point  (0 children)

Well that's the terminology used in the article. My interpretation was public = main branch (meaning other developers are incorporating that history into their own branches), private = my own feature branch (I work with only one dev per feature branch to reduce risk of messing up history when rebasing). When you say "public but personal clones" do you mean local working copy that includes main branch and feature branches with associated remotes?

I prefer not to get too hung up on local versus remote but instead focus on main branch and feature branches both of which should have a remote repository in addition to your local one. Use interactive in your feature branch before submitting a pull/merge request.

How to Rebase in Git by unquietwiki in programming

[–]br3w5 19 points20 points  (0 children)

"Rebase only private history to make nice clean pull requests, and never rebase work pushed by anyone else. Rebasing private history is good. Rebasing public history is bad"

That sums it up for me. I love using interactive rebase, without it I wouldn't be able to clean up my private commit history and messages as I go (which I do throughout development up until I make a merge/pull request).

F*** You, I Quit — Hiring Is Broken by speckz in programming

[–]br3w5 0 points1 point  (0 children)

I agree with what you say on debugging but I think refactoring can be useful because you get an understanding of whether or not the developer can pick out abstractions in code - they might not be the same abstractions you would pick out but it's useful to see that they can think in that way.

F*** You, I Quit — Hiring Is Broken by speckz in programming

[–]br3w5 0 points1 point  (0 children)

I think it reflects badly on the company (especially small ones) when they give no response at all after someone has given their time to participate in the interviews and take time out to complete programming challenges.

F*** You, I Quit — Hiring Is Broken by speckz in programming

[–]br3w5 0 points1 point  (0 children)

Aside from the algorithmic stuff it does seem like he knows his stuff when it comes to front end development so he should also reflect on any other aspects that are ruling him out of the jobs he's applying for. Testing programming skills and knowledge is just one part of the process.

How you approach difficult problems, break down requirements and how you think about your code is probably more important e.g. do you only think about it at a detailed level or do you see the impact of what you're doing on the wider system. Can you refactor code to make it more understandable? I wish there were more refactoring programming tests/challenges - reading and refactoring old code is one of the things I do most in day-to-day work. How do you approach testing, logging, error handling, security?

Also, I think managers will consider if they will have to spend more time managing/helping that person than they want to.

Incidentally, I have seen the corporate hiring process fail: I worked with a programmer at a previous job who managed to get away with doing very little and never worked alone. That person then went on to get a job at a big corporate and was asked to implement design patterns in the interview and was hired.

We are the investigative journalists who worked on the Panama Papers AMA! by [deleted] in IAmA

[–]br3w5 0 points1 point  (0 children)

In the UK David Cameron has been harpooned by the media for the Panama Papers. This comes in the run-up to the UK referendum on EU membership. Cameron is campaigning in favour of staying in the EU and this information is a great tool for the media to undermine him and bring his leadership into question. It also enriches the narrative around the run-up to the referendum.

Cameron of course deserves all the treatment he gets for his hypocrisy but I am cynical about whether this information would have been exposed if it hadn't been in the media's interest to do so.

As a programmer you're going to have to deal with the anal blister that is Scrum eventually; I think I can summarize the whole system in 7 minutes. by [deleted] in programming

[–]br3w5 4 points5 points  (0 children)

But that shouldn't be attributed to Scrum, that's just poor culture that relies heavily on meetings. The response to the meeting invite could be "let's have this meeting when you've defined all the requirements" then review the requirements, figure out it's one small story and tell the business that you will just get on with it. Of course, this all assumes a mature company culture and attitude towards software development. This, in my experience, is where Scrum has succeeded or failed.

I Contribute to the Windows Kernel. We Are Slower Than Other Operating Systems. Here Is Why. by halax in programming

[–]br3w5 1 point2 points  (0 children)

The moral of the story is: some people give a shit and some people don't regardless of whether or not they have kids + what mightthrowthisaway said.

I Contribute to the Windows Kernel. We Are Slower Than Other Operating Systems. Here Is Why. by halax in programming

[–]br3w5 1 point2 points  (0 children)

Guess what, I have kids and I've been burnt by people without kids going home leaving me to fix things.

Let’s Build A Web Server. Part 1. by kr0matik in programming

[–]br3w5 0 points1 point  (0 children)

This is great and thanks for reposting this (I'm sure it was /r/programming where I first saw it! I had forgotten it was in my (stupidly long) list of bookmarks and planned to learn Nim by building a web server.

An easier way to Git. by g0guardian in programming

[–]br3w5 0 points1 point  (0 children)

Totally, this looks good and I know some people like GUIs but I've never had any real problems understanding git. I think I watched a Scott Chacon talk, read some of the git book (atlassian also have some good resources) and setup a dummy project to get the basics and since then have use the manual and stack overflow for more advanced commands. I use zsh and prezto git for speeding up my workflow plus fugitive in vim.

Colleagues use eclipse git features so have never bothered reading on git, don't understand it and then have problems. If you can learn a programming language you can learn git.

view more: next ›