711 karma · joined July 9, 2012
Not all software telemetry is that creepy, but things like google analytics definitely are.
The benefit of having it in a separate bank is that it hugely increases friction when you start thinking about spending it, since you have to move it back to your primary first. You can mostly forget about the specific numbers in it as well since it isn’t visible in your primary bank dashboard.
ORMs aren’t bad, but learn their escape hatches or else you’ll have a hard time doing more complicated things.
Without weight lifting or forcing yourself to eat way more than you should do you retain more fat, you may just have a slim build.
2) That’s incsearch, `set noincsearch` to turn it off.
Visual programming languages are not designed for experienced programmers, who would rather type it out. It's designed for those who don't have a programming background, but still might need to wire up some logic on occasion. It's not necessarily meant to be efficient, just user-friendly to someone with no programming experience. If this language makes it easier to write tutorials or get into making games for people coming from an art or design background instead of a programming background, I'm all for it.
Debugging: Fair enough. VSCode is starting to stray toward IDE, which the others described specifically exclude. They focus on the text editing and leave the debugging for other specialized programs. VSCode would make sense to be an IDE since it's coming from a Visual Studio lineage though.
Multiple Projects per Workspace: Sublime has this as a project can have any number of folders added to it. A sublime project is equivalent to a VSCode Workspace unless I'm missing a nuance somewhere. Vim and Emacs are less useful in this regard, though they have project management plugins. Most of the time, Vim and Emacs will just save off a workspace in what they call a "session". You can load the session and be exactly where you left off (down to the cursor position). These can also be configured to happen on startup/shutdown.
Electron apps might beat other electron apps (VSCode over Atom), but we're still a long sight off from electron apps beating compiled ones in most cases.
I can't find any data to back that up, can you point me at some?
> Function<Integer, Integer> f = x -> x + 1;
Fair point, didn't know about Function
> I think you haven't seen Java's standard library recently.
I dislike the standard library. It feels kludgy, as if things were added haphazardly for the last 20 years. It's still missing valuable things that have been around and proven to be very common and desired, like format reading/writing (CSV and JSON come to mind). The HTTPServer implementation is even in com.sun.* and isn't part of the official standard library. Oracle even has a page telling you not to use it: http://www.oracle.com/technetwork/java/faq-sun-packages-1422...
> This is one area where Java is ahead by a large margin in almost every single component you list.
Java as an ecosystem, they may be ahead in some ways (IDE + Gradle). But Java is not, they are missing most of the components I listed. You have to use an IDE and Gradle/Maven to come close to the out-of-the-box experience with Go. And I did note that IDE support is one of the negatives.
The Good:
* Performance. Java and the JVM are certainly performant once things get going, but Go and other compiled languages are at peak performance out of the box. Go should generally be a bit faster or equal speed to Java and should use a fraction of the memory. Here's some microbenchmarks that look good for Go vs Java: https://benchmarksgame.alioth.debian.org/u64q/go.html
* Concurrency. Go makes it simple to communicate and synchronize with other threads, and the co-routine model allows for expressiveness in async without running into callback hell.
* First-class Functions. Some JVM languages have this, but even Java 8 doesn't have the ability to set a variable equal to a function definition. Coming from Node, Python, C, C++, etc. Making functions first class citizens helps a lot.
* Interfaces. Go has auto-fulfilled interfaces that you opt-in to by writing the functions they require. The compiler figures out which types match an interface for you, instead of you specifying it. This is probably my favorite feature of Go. It feels like duck-typing with type-safety.
* Unicode support. Go has excellent unicode support, which I don't think any JVM language has. Javascript also has great unicode support. This is probably a big one for someone doing a lot of web-based application deployments.
* "Batteries included". Go's standard library is amazing. All the basics you'd expect like string manipulation and math functions are there. They also have a dead-simple http server/client that supports http2 and SSL. Full crypto libraries with key-management. Encoding/Decoding for csv, json, and xml built into the standard library, even compression formats. The standard library feels really good to use compared to C++ and Java for me. C# I believe is on-par with Go as far as built-in libraries go.
* Compiled and statically linked. Go only does static linking for Go code, and does interoperate with C (but it's awkward). This means you compile the Go program and then run it, the runtime is in the binary. There's no worrying about versions of your JVM and ensuring that class paths are set up correctly. A single binary executable is all you need and what you get out.
* The tool chain. Go comes built in with documentation generation (really nice stuff, everything on golang.org/pkg is automatically generated from the source and comments), testing facilities (including coverage tools and benchmarking), and dependency gathering (like pip without the versioning). The dependency gathering uses VCS, so you can point it at any mercurial, svn, or git repo and Go will go download and put it in the right spot for you. The compiler can do cross-platform compilation from your local machine (on windows machine, compile for linux) with some playing with the settings. There's a race detector, code formatter, and version upgrade tool in there too.
The Divisive:
* Error handling. A lot of people I've seen using Java/C# like exceptions for error handling. Go doesn't use exceptions except in exceptional circumstances (and no try catch when that happens). Go instead recommends you use secondary return values (since you can return multiple values) for your errors. This leads to a lot of code that says `if (err != nil) { return nil, err }`. I find that in my first pass, that line is everywhere, but when I start building toward production of the system, I'm responding to the errors fairly deep in the call stack and the number of default error lines drops dramatically. Your mileage will vary.
The Bad:
* No generics. This might be a deal-breaker for you, depending on how you like to program. Go has first class support for a simple hash map (generic) and dynamic arrays (with slicing semantics similar to python) (generic). Every other generic collection type you might want will be made yourself, made by code generation with a third party module, or lacking any type safety through the use of `interface{}`. Generics are probably going to come at some point, but not yet.
* Package version management. While Go makes it easy to get the latest version of a package, Go does not have a robust package version management system yet. Getting the specific version of a package your project needs is difficult and error prone at times. Third party tools are currently the best way to deal with versioning and freezing your dependencies. Hopefully the `dep` tool or something like it will become a first class part of the tool chain, but it's not there yet.
* Debugging and IDE support. There's still not a lot of IDEs that support Go, but it looks like JetBrains may be fixing that soon with a dedicated IDE: https://www.jetbrains.com/go/
* Lack of expressiveness. In Go, there is often only one way to do things. Go is specified in it's entirety in under 30k words. You can write a whole compiler based on that information. That means it's lacking a lot of nice syntax that's become popular: Option types, pattern matching operations, decorators, lambda expressions, etc.
Cost to Connect: $1250 - $300 = $950
Cost to Maintain/Year: $600
Price/Year: $840
So, assuming that the income chart looks sort of like this, then the point at which it becomes profitable is 4 years. And this assumes that Google doesn't get more efficient.
do<A>(a)
do<B>(b)
Can I take any arbitrary type with an "int do()" method and use that with do? Like: do(Arbitrary) set list
set listchars=tab:▸\ ,eol:¬
it's in the getting started section.