HNHacker News
TopNewBestAskShowJobs

peterevans

406 karma · joined December 18, 2012

https://www.modul8r.com/
submissionscomments
peterevans··on Go 1.10 Release Notes
Like I said: Go does everything C does, but better.

I suppose you could write your own malloc in Go... if you preallocated a bunch of bytes in a huge chunk, and wrote some functions to use that up. But that sounds like a pain.

If you really really specifically need to manage your own memory, then I agree, you shouldn't use Go. But that doesn't mean that Go is not a valid replacement for C. Do you think a majority of programs that are written in C are done so because they need to manage their own memory?

peterevans··on Go 1.10 Release Notes
Expressiveness can be good–but at a conceptual cost, because you must now understand how those fewer lines of code do the same thing as a program in another language that isn't as expressive.

I'm glad it's a big win for you! But in the main, I think, it's a tradeoff. Expressiveness has a cost; simplicity has a cost.

Personally, I think it's best not to get too attached to specific concepts or languages, because times change, and needs change. If you're a good programmer, you can learn any language and any concept you need to.

peterevans··on Go 1.10 Release Notes
Go is like the Six Million Dollar Man language, compared to C. It's everything C can do, but much better.

Both C and Go are very, very simple languages; there aren't many keywords, and it's pretty easy to grok both at a functional level. It takes, of course, a bit to reach the second-level understanding you need to make full use of either language, but it's easy to hit the ground running in both.

We sometimes get stuck on one language being better than others because it has X feature or Y concept, and I've seen some people essentially root for one language over another. But at the end of the day, languages are tools to get your work done, and on balance the work is going to be hard whichever route you go. Use the one that suits the talents you have available and that broadly complements the needs that you have.

peterevans··on Advantages of monolithic version control
Sorry—I just saw this! But, as it was, I was not saying that you should release a patch version every time you make a code change. That would indeed be pretty arduous!

What you should do is test your library independently from the consumer that uses it. If that's not possible, ask yourself why that is; maybe this code should not be sequestered into a library after all, or maybe it needs to be designed a bit differently to remove some of the coupling between the library and app that seems to be at issue.

Ideally, your testing in your app should not be testing that the library works; it should be testing that your use of the library works. Too bad the real world is much messier than the ideal world.

Good luck either way!

peterevans··on Serverless Databases: The Future of Event-Driven Architecture
I understand your point; my issue is that "serverless" as a term is a misnomer. You cannot have a serverless architecture without some servers to support it.

The "serverless" distinction is a useful one to make, because it implies something about the architecture as you mention—my only point is that we could have done much better with the name we use to reference said architecture.

peterevans··on Serverless Databases: The Future of Event-Driven Architecture
I was hoping the future of event-driven architecture is that we would call it "event-driven" and not serverless; alas.
peterevans··on Advantages of monolithic version control
Yeah, I sympathize—that's a tough situation.

I think there's two ways you can look at your choice of configuration: ease of debugging, and ease of organization. When Google lays out why they use a monorepo, they are doing so because it simplifies their organization—there are no longer so many versions of so many libraries and apps they need to support; there's only one version of anything to support. Either everything works or everything fails.

But in your case, you're looking at it from the debugging point of view. It's easier to play around with the code in a monorepo. And that's totally fair point of view to have, particularly in your predicament.

That choice of a monorepo doesn't necessarily improve the quality of your code organization and interoperability. It's still going to be a bad bug to fix. It's just a little bit easier to debug.

peterevans··on Advantages of monolithic version control
What does your test coverage look like? Perhaps you're missing something there that would have caught that bug?

Testing is, of course, no silver bullet. Tests are written by humans, and humans make mistakes—and it's pretty difficult to achieve 100% test coverage in a production system. The goal of testing is to have confidence in the code you've written.

Tests often don't need to cross version control boundaries. You can use mock data—like would be produced by the library—on the consumer side, because you can delegate responsibility for testing of that library to the library repository itself. If your tests work great with the mock data, but things are still failing, then you can infer that the mock data and the actual data are different, and your bug is in the library.

peterevans··on Advantages of monolithic version control
Ideally, your library code that you're pulling in has some unit testing to demonstrate that things are working as they should be. (If not, consider adding unit testing! It's really useful!)

If that is the case, then you can isolate the likelihood of an issue as either in the library (because unit tests fail there), or in the project consuming the library (because unit tests succeed in the library).

Without testing, it's hard to have a ton of confidence in where the problem lies—which is exactly the problem you cite. And while a monorepo (or just a standalone repository with no separate libraries, which is frankly an easier setup to manage than monorepos or multirepos!) may make debugging a bit easier, it's not going to give you much more confidence in your code.

Once your organization outgrows the paradigm where you just have N standalone projects with N completely separate code bases, and you do need to commit to either a multi-repo or a mono-repo configuration, it's really, really helpful to have unit testing to allow you to isolate where issues are.

peterevans··on Advantages of monolithic version control
Any changes you need to make to internal libraries you install via package manager would need to be made to those separate repositories that house the libraries, and then those changes would have a release made (generally this is done through a git tag, and using semantic versioning). Once you update the version, your package manager will allow you to install that update to the other places you're using it, so all you need to change is the package file.

It might seem like a pain to do it this way, especially if you're rapidly iterating on a library—it might be that your library is not really mature, or even used by more than one repository, so it may not even make sense to have that library in a separate repository to begin with! But once you do have a mature code base, semantic versioning is a really sane way of managing dependency updates for the N number of other projects which use your library.

peterevans··on Advantages of monolithic version control
Using multiple repositories seems like the most natural workflow to have. It's easy to make a new one; it's lightweight to do, and it allows your code base to scale naturally. You can set permissions for each repository, so if you did include some sensitive code within one repository or another, it's easy to narrow the access to them. (Yes, don't include sensitive code in a repository—but in an early-stage company, you or your engineers may not know that.)

Multiple repositories make for a forgiving structure for your code base. You can tailor them however you like.

But once you have a _lot_ of code, they become hard to manage. I see the utility of a monolithic repository there—now you know exactly where all your code is: it's in this one repository!

Package managers mitigate a lot of the trouble with pulling in internal dependencies from other repositories. Nowadays, most languages have a package manager that can work with a private codebase, so monorepos aren't necessary to help with that. But monorepos can help if you have a ton of versions floating around and you don't want to support version 1.5.x of libjohnny when it's now on 4.3.x. Your code either works with libjohnny as it is right now, or it doesn't. (Which in turn makes it very clear to you how important it is to manage API-breaking changes!)

This feels a little bit rambling, but my thought is that there is some analogy between monorepos and microservices; don't use them until you _need_ to use them! You'll know it when you get there.

peterevans··on Slack is the opposite of organizational memory
My worry is that if Slack is replacing your documentation, then it may be that your organization did not have good (or any!) documentation that predated its use of Slack. As such, I'm not sure if that's a fair thing to criticize of Slack.

Slack is a tool for productivity. (Go on––I'll give you a minute to laugh.)

Slack does make it easier to talk to people, particularly so in a group setting. Any company can make use of that; if you are a remote company, you need that. JIRA and Trello are also mentioned as "hates", but these are also tools that make it easier to work (notably, to make it easier to organize and catalog work). If you aren't using them, you've probably written a hack that does something like them, only worse.

peterevans··on MailChimp’s founders built the company slowly by anticipating customers’ needs
I don't think it matters as much as you suspect that one company is bootstrapped and the other is VC-funded. I'm sure you can find dozens of examples of VC-funded companies being floored by other VC-funded companies.
peterevans··on [dead]
Running `go build` is a lot like running `make clean` before you compile.
peterevans··on Anti-if: The Missing Patterns
Agreed. The sumOf function is now made more brittle by that fact, and would be unworkably so in a publicly-available API. This is easily fixed by a try-catch block if one finds that they are indeed allergic to if statements, although that too is a form of flow control. If you are programming in Go, you're going to have to bite the bullet and use an if.

(I suspect the author would prefer jumping in a lake over programming in Go.)

I think it is also worth mentioning that passing a new ArrayList over a null value is somewhat wasteful of memory. Though the reference to ArrayList will cease to exist, its allocated memory will hang out until the next GC phase. In the words of Bartleby, I would prefer not to.

I get the principle that is being advocated, but the solution code doesn't pass practical muster for me.

peterevans··on Linus Torvalds on C++
I think I understand Linus' concerns. I guess I'm not sure how you conclude that I do not, but, so it goes.

Languages do change, and implementations evolve. I think it's fair to temper criticism with the caveat that, hey, this was from a while back. And Linus' comments certainly were from a while back, considering the latest one was made in 2007. You didn't have shared_ptr, you didn't have unique_ptr, there was no auto type.

I'm not going to argue that these things make C++ awesome. I really don't work in C++ on a day-to-day basis. But the language is certainly different now than it was in 2007, and I think that does matter. At least a little bit :)

peterevans··on Linus Torvalds on C++
Well... not to be a C++ apologist, but bear in mind that these comments were made by Linus back in 2007 and 2004. His views may not have changed, but C++ has certainly changed since then.
peterevans··on Some Rookie Mistakes in Go
I don't think the post here is actually asserting not to use a web framework; just that you should not use a specific framework, named Revel, that aims to be Rails-esque. It brings up an interesting point for me about what is really possible (or desirable) in a framework written in a statically-typed, compiled language like Go compared to a dynamically-typed, interpreted language like Ruby.
peterevans··on Dear “Dear GitHub”
This is no knock on you, since you aren't there to develop the Issues platform anymore. But I don't know how much private repo developers are hurt by the points made about Issues because they probably don't use it.

I mean, Issues is not really a full-featured issue tracker. It could have been, and maybe would have become one when you were still there, but right now, it's not. And if you do need something more, and you have some resources within the organization, you're not going to stew over Issues...you're just going to use something else. Jira...Pivotal...whatever.

I'm sure GitHub doesn't feel that Issues is where they make their money. And/or that developing Issues further either won't make them anymore money, or not enough to matter. People don't choose to use GitHub for its issue tracker, and even if they had a great one, people still probably wouldn't choose to use GitHub because of it. And so Issues languishes in its current state.

But Julian Dunn has a point to make--maybe this press burns enough for GitHub make changes after all.

peterevans··on The shortest paper ever published in a serious math journal explained
One of the authors, John Conway, is the inventor of the Game of Life: https://en.wikipedia.org/wiki/John_Horton_Conway.
peterevans··on Software development: do good manners matter?
You're right, and they do acknowledge this to some degree in section 5 ("Threats to Validity"). The projects they monitored were unaware of having been so, therefore the authors would have had no way to observe much nuance. They could only what was publicly visible.
peterevans··on Yahoo Talent Exodus Accelerates as Marissa Mayer’s Turnaround Flounders
It doesn't seem that any of the people who left were remote workers. I mean--maybe they had felt some solidarity with their remote-working coworkers--but I suspect that Yahoo's problems run a little deeper.

The company promised a turnaround that hasn't happened. The people leaving largely seem to have been in positions to have a strong sense for when and how such a turnaround would come to fruition--and their actions suggest to me a lack of confidence.

I do agree that the memo didn't really help the company in any notable way. Whatever it could have helped was surely more than offset by what it could have--and did--hurt.

peterevans··on Fixing a Disk Space Alert at 3 AM
Good thing the author wasn't randomly rewriting a file, then, and that the file was deleted and inferably unlikely to be used in a critical operation!

Restarting MySQL is a violent operation. For large databases, it can take several minutes. If I can avoid it, I do so, and this was a really clever workaround for an issue that indeed avoided a restart. That's a good thing.

peterevans··on FoundationDB's Lesson: A Fast Key-Value Store Is Not Enough
It seems like John had some technical points to make. It's hard for me to justify his post as "slamming" FoundationDB if his assertions are based on logic. Now, if you have a criticism of his points, you should feel free to rebut them. You certainly have not do so here.
peterevans··on Wherein the Facebook Morality Police have decided that we are porn
I'm saying that, as someone who has read his various rants throughout the years on jwz.org, and followed his twitter feed, I can say with a great degree of confidence that a) he didn't post this to HN, and b) he really couldn't give enough of a shit to "viral market" anything.

You're free to form your own opinions, although if you must, I would urge you to avail yourself of the opportunity to read through his website and past writings. I find your continued contention that he is using viral marketing to be rather amusing.

peterevans··on Wherein the Facebook Morality Police have decided that we are porn
If you think jwz is doing some "viral marketing", then you're really lacking in your knowledge of net.history. Ending your post with "flagged" makes it doubly foolish.
peterevans··on Attack of the week: FREAK (or 'factoring the NSA for fun and profit')
I think that's what Matthew meant exactly. "Nadia doing quite a bit of handholding to deal with crashes" -- Nadia is the that's doing the hand holding, rather than needing it. I think OP misunderstood when reading.
peterevans··on Small Amounts of Gluten in Subjects with Suspected Nonceliac Gluten Sensitivity
Actually, it's really great! Because it allows people who have an observable intolerance to gluten to eat food. That's a nice thing, isn't it?

What's unfortunate is your dismissal of (scare-quoted!) gluten free food as a health fad, but so it goes.

peterevans··on Chicago startups to watch in 2015
I imagine if they had data, they wouldn't have trotted out tired gripes and stereotypes in the first place...
peterevans··on Show HN: Matterhorn – Your new project manager
Definitely more information about your integrations would be really helpful. For software like this, having an integration with Zendesk to bring tickets into the tracker or Github Issues into the tracker is essential; to the point where having an open API is great, but you're probably going to have to do the legwork for those integrations.

Having said that, I think there's a lot of room for improvement in the issue tracking space. Good luck!

← PreviousPage 2 of 4Next →