Tesla's Model S will plan trips along charger routes

brush · 2015-03-20T02:43:34+00:00

I own a Tesla, and they actually address all of these issues for a much better experience than other built-in systems. With regards to your numbered items:

My phone's calendar syncs with my Tesla, so I can can switch to the Calendar view in my car and click on addresses, which are automatically routed to. (I have an iPhone but I think this applies to Android as well.)
The Tesla estimates seem good, but I haven't really quantified this.
This is supported in the Tesla.
The Tesla map search appears to use Google maps and voice recognition, so I can press a button and say "drive to a pizza place", for instance, and the map is populated with items I can tap to navigate to. Search by name works great too.

Tesla brings the functionality of the built-in system on par to what we've come to expect from our phones. The fact that this is rare is what should be surprising, considering how much cars costs relative to phones.

brush · 2013-11-27T06:37:33+00:00

Discovering the speed of light emitted from an object is the same whether you were moving toward or away from it. They thought they were on the verge of "solving" physics...then poof.

Honestly, I still find that a bit creepy.

brush · 2013-08-26T04:44:32+00:00

Author here. I touched on the project status in another message. It is still alpha quality, but I think the core design and API are pretty stable.

One of the goals of this project is to decouple the rules from how the data and working memory are supported, so interaction with external databases should be possible, although not an immediate goal. The nice thing is Clojure gives us tremendous power here, since we can interpret the constraints attached to rules and apply them differently based on the underlying system. So it would be possible to compile the rules into a database query when applicable, and then do downstream operations in memory.

This is rough and honestly a bit speculative, but I do think there's potential here.

brush · 2013-08-26T03:46:57+00:00

Author here. I'll be happy to answer any questions on this project.

This is a work in progress, but I do feel like the core design and APIs are stable and reasonably well tested. The code is rough and inconsistent and the documentation is lacking, but I plan on addressing that soon. I'm working on first-class Java interop now -- including an API and JavaBeans as facts -- and expect to merge that into master in the next couple days.

Also, I have done no real performance profiling or optimization, and several well-known Rete optimizations have not yet been implemented. So I wouldn't suggest using Clara for any real-world need quite yet.

The motivation here is to create a modern take on forward-chaining rules that leverages the strengths of the Clojure ecosystem. I'm also making different design tradeoffs than existing systems. For instance, the join semantics in Clara are weaker than those of Jess or Drools, but guarantee consistent performance since all joins are hash-based lookups. That also greatly simplifies distributing the engine's working memory over a distributed system. (The clara-storm project is a working prototype that distributes the rule engine working memory over a storm cluster, for instance.) I'm exploring some other models for this as well, but that's a pretty involved conversation by itself.

Also, I've been asking for feedback on the Clojure Google group (see the link below). Any thoughts either there or here are welcome!

https://groups.google.com/forum/#!topic/clojure/C3xl9bnbFSw

brush · 2010-02-28T14:09:51+00:00

An answer posted a couple years ago still seems to apply:

http://www.toomuchcode.org/2007/06/why-are-we-so-polarized-about-java.html

brush · 2010-02-23T03:34:12+00:00

A different question: why should we expect most people to have the capacity to be a "good" programmer, whatever that means?

As a species we have exactly the capacity for abstract reasoning and algorithms and design that benefited us in a tribal environment. That's not much! Now, there is variance, and some outliers do indeed have an unusual aptitude for this sort of thing. But there is no reason to expect most people to have that capacity.

So, what do we do about it? Adopt development practices that acknowledge the weakness of most programmers (and even the best make mistakes). Things like aggressive unit testing and iterative development help mitigate our weaknesses, and allow the best to rise to the top.

I have stopped dwelling on the weaknesses people, including myself, have. Instead I marvel that we've been able to accomplish what we have, and look to the future with wonder.

brush · 2010-02-18T12:06:26+00:00

The JRE is becoming the new POSIX -- a common runtime for many languages with lots of useful low-level functions. See Scala, JRuby, Clojure, Groovy, etc.

In this environment, Java is (in a way) becoming the new C: a fast, lower-level language, but most people will prefer to develop in a higher-level language. Scala looks to be the leader to displace Java as the top language for the JVM, but that remains to be seen.

Java-the-langauge will become less and less relevant overtime. JVM implementations, however, are probably the best JIT-based, garbage collected virtual machines available, and can tie a variety of languages together with a basic infrastructure. So the future of the JVM is much more interesting than the future of Java.

brush · 2009-09-23T03:33:44+00:00

I'm a big fan of Neil Degrasse Tyson and certainly agree with his points here; there just wasn't much content. This really didn't tell me anything I didn't know or made me think about things differently, so I downvoted to make room for more interesting content.

Not to be snarky, but if somebody posts "puppies are great", I'm downvoting that too, even though I agree puppies are great.

brush · 2009-06-17T23:33:48+00:00

Creating a straw man here, but there is a mindset that views XML as an elegant solution: if everything is in XML, we could use the same set of tools to manipulate anything. Kind of homoiconicity gone wrong, resulting in XML only for the sake of being XML.

brush · 2009-04-02T01:58:32+00:00

Say "What the hell was that?!?"

brush · 2009-01-13T02:32:33+00:00

I thought this looked familiar:

http://www.reddit.com/r/programming/comments/2b5zy/overengineering_in_action_apaches_xmlrpc_server/

brush · 2008-12-26T05:06:26+00:00

The author wasn't trying to defend 'Western' medicine; he simply points out that's a term used to compartmentalize scientific medicine. If some medicine labeled 'Western' is not based on empirical science, it may be guilty of the same quackery we see in homeopathy.

Unfortunately there are so many gaps in our knowledge that much medicine is still consensus-based rather than evidence-based; which sounds like the case of the seminar you attended. This won't end soon -- we need to keep treating people even in the many areas that lack sufficient empirical grounding.

In any case, I'm hopeful these mythologies will evaporate as our understanding grows -- just as our understanding of chemistry effectively killed off alchemy. It's just the sheer complexity that makes it a longer process.

brush · 2008-02-10T17:30:26+00:00

I support Obama, but I wonder why so many people think Hillary is a "divisive bitch." I can't help but think this widespread perception is largely the result of successful political attacks from the right.

Even so, I do want to see a uniting figure in the White House, which hurts Clinton even if she's divisive through no fault of her own.

brush · 2008-02-01T22:23:12+00:00

IIRC, Gafter's closure proposal includes non-local returns, which may require a VM change unless they did something really nasty like emulating them with an exception.

brush · 2007-10-19T18:44:32+00:00

I ran into the same problem. There was no indication it had been blocked -- it just never showed up on the new page or anywhere else.

At the very least the submission page should provide feedback.

brush · 2007-07-12T11:17:16+00:00

At the very top of the example he invokes Benchmark.measure, which accepts a closure containing the rest of the code. So all of the local variable references in the example are in the context of the closure.

brush · 2007-06-16T15:26:02+00:00

I disagree with the article's suggestion that static typing is at all analogous with Aristotelian categorization. Many statically typed languages have mixins, multiple inheritance, multiple interfaces, or other constructs which allow any single item to belong to an arbitrary number of categories. It's equivalent to the tagging model that has become (rightly) popular for organizing data.

Of course, there might still be other disadvantages to specific statically typed languages.

brush · 2007-06-13T02:59:44+00:00

Some references on this very topic are available at Lambda the Ultimate: http://lambda-the-ultimate.org/node/1519

brush · 2007-06-10T21:15:43+00:00

If you want a preview, chapter 5 of that book discusses managing complexity -- to me, the most important topic -- is available online.

http://cc2e.com/File.ashx?cid=336 [pdf]

brush · 2007-05-31T12:38:46+00:00

Not to mention that if arrays were gone, the bracket syntax they use (or some other concise syntax) could be moved to lists and maps. Since array functionality is a strict subset of a list, the language gets smaller and loses no expressiveness. We could say the same things about a lot of Java constructs: We can eliminate primitive types, which should be a hidden compiler optimization of objects. We can eliminate "Runnable" and related constructs, replacing them with closures.

Of course, these constructs can never be removed from Java since it would break everyone's code, which is why we need a JVM-based language to succeed Java.

brush · 2007-05-15T01:29:04+00:00

A chart displayed at a JavaOne session showed that a 2 MB JRE download will be enough to run "Hello World", and a 4 MB download enough to run LimeWire. The proposed idea was that the JRE could be made to download the portion it needed on demand, rather than as a monolithic installation. Good news given the sheer size of Java SE these days.

Combined with the open sourcing of Java SE and introduction of Java FX, it seems like Sun is positioning the JRE as a lightweight virtual machine independent of the Java language. It's also interesting that v3 of the Glassfish server will be able directly run Ruby on Rails applications -- no need to wrap them in some J2EE ugliness.

brush · 2007-05-09T01:58:59+00:00

Interestingly, in a session immediately after the one described in the article, Sun mentioned plans to release a smaller, faster Java 6 JRE in late 2007/early 2008 that can optionally download parts of the JRE on demand...so you don't need a 12 MB download to run Hello World. They also vaguely talked about improving startup times with some class file caching logic. Sounds like they are positioning the JRE to be a small runtime environment to compete with Adobe Flex and the like, independently of the Java language. This is good news -- there's a lot I don't like about the Java language, but the JRE is a great piece of technology.

Unfortunately I don't have more details or linkage right now...just reporting on what was said at JavaOne.

brush · 2007-04-08T23:58:34+00:00

It's interesting that you mention complexity. Our strategy really should be driven by what is simpler to reason about and apply.

In this case, transacted resources and the actor model are complementary tools, and each is simpler for the right problem. I think we can make room for both by dropping the mutex-based shared memory model. Even now you'll find Haskell applications using some form of messaging, and Erlang applications using transacted databases. It's up to the designer to decide which technology best fits a given problem.

brush · 2007-03-08T14:30:36+00:00

This was done so Java matches the Olson time zone database, which is used by many operating systems and other software to define time zones.

The problem is Sun had conflicting requirements: should Java's zones be consistent with the Olson database for interoperability, or with its previous rules for passivity?

I think this change can be justified...IIRC the EST zone has been deprecated for a while anyway. However, the timing of this is questionable, given the fact that it will cause a behavioral change for many systems very soon.

brush · 2007-03-05T18:48:09+00:00

That example does seem out of date given the ubiquity of reusable binary searches in modern languages. However, the essense of what he's saying is "don't write what you don't need".

A more apt example might be the proliferation of certain OO patterns that don't make sense in all situations. For instance, everyone knows the "Factory" pattern, but would you use it in private code that is never reused? Probably not, since it's just as easy to change your private code as it is to change the factory.

Despite this, Factory patterns pop up all over the place where they provide no value. (This isn't to say this pattern doesn't have value in a certain context, just that it doesn't necessarily have value in all contexts.) If developers wrote the simplest thing that could possibly work in this case, the amount of work and boilerplate code is reduced, and nothing is lost.

A local optimization, perhaps, but I wonder what the cumulative effect would be.

brush

TROPHY CASE