Apple Robots

When will the world be ready for personal robots? For some years, I've answered that question as: When Apple releases a robot.

I don't buy Apple products. I don't particularly care about them. But they have a history of frequently knowing when the right time is to introduce the right kind of product. There were Windows tablet computers years before the iPad. And back in early iPod days, Steve Jobs told everyone about how nobody cares about mobile video watching, for example. And then there's the iPhone and iPad, anyway, at the right time to take off.

They don't have a perfect track record of success, but they've been pretty good.

I want to see personal robots, and they've been made for decades. And Google getting into robotics and AI companies is great. Apple making a car is better news, though. If Apple can make cars, Apple can make robots. Even the car is still years out, but we'll see.

And I'm clearly not the only one interested in this angle. I could probably find other examples, but finding one is the most I want to spend time on for now.

Indirect Generics

I've been rethinking an old programming language idea I've had. I don't know if anyone else does things this way. (But probably, because Ecclesiastes 1:9.)

The goal is to allow generic code. Or said differently, to code in a domain dependent fashion. And to do it with as little pain as possible. Let's start with a commonly generified structure: arrays. And let's use standard templates/generics syntax:

class Array<Item> {
  Item get(Integer index) ...
}

// Declaring an instance.
Array<String> strings = ...;

With my idea, I could just treat them as different types:

class Item {}
class Array {
  Item get(Integer index) ...
}

I'm not getting too deep into syntax I might like to use for these examples. Instead, I'm staying approximately in Java land.

Here, Item is an abstract type (ignoring differences between classes, interfaces, and whatnot). And other types and functions in this module could use it just as easily. And it enforces no constraints, just as you might expect for the kinds of items you could put in an array.

In fact, this looks a lot like Lists in Java before generics came along, except that they reference the standard type Object. But how to make a specialization without explicit type parameters on Array? Easily enough:

Array<Item: String> strings = ...;

I'm usually a fan of named params anyway. Because this could get bulky, there might also be some syntax to allow positional arguments. And typedefs could also be handy for commonly used specializations.

Note also that we assume String can take the place of Item, so we're assuming structural typing or some such here, since String will not have been defined as a subtype of our domain-specific Item.

Of course, for more interesting situations (constrained generics), simply put other members in the types you want to use.

The overall idea is that when you are coding some module, just invent the types you need as you are going. Work in your own domain. Let the adaptation come later. (So, you might want to pay some attention to standard interface members, etc., but don't die over it.)

Three Aspects of God

When people debate the existence of God, I think there are at least three different aspects (semi or fully orthogonal dimensions) of discussion:

1. God as creator. Did the universe just come about, or is there an intelligent designer behind it? (I'm not talking about 6-day creation specifically here.) This question is hard to resolve logically. On one hand, you have science that seems to make further and further progress answering questions that were previously just "God made it that way." On the other hand, however far the mechanisms get discovered, there are always more questions behind them of how things got to that point in the first place. And then there's the meta question of why anything exists at all (including either God or eternal inflation or whatever else).
2. God who interacts. Is there some all-powerful, intelligent being who maintains active involvement with the universe and especially with people. Some entity that understands our language and can alter the natural course of events or, in some perspectives, maintain them. If I pray, can God enlighten me? Can God heal an illness or part the Red Sea? For many, this is an individual question who feel God's influence. My understanding is that some research exists on how people who pray or meditate or participate in church actively or other social groups might outlive or be happier than those that don't. That's vague enough, I'm not sure what can be said specifically on this matter based on research. Some believe they've seen miracles in their life. Some would say it's post-hoc analysis or selective attention. Also, if God is active and for some reason wants to stay hidden from scientific inquiry, could this being purposely choose only to be active in ways that aren't easily investigated? Maybe with occasional Red Sea partings or highly witnessed resurrections? (I reference Christian themes best because I know them best, but there might be others to consider.) And is it possible that God leaves memories of himself in us for delayed interaction. That is, do we interact with God's imprint rather than using some underlying faster-than-light universe-spanning interaction? Or if God does interact, does this being care about whether we are happy or not?
3. God who defines right and wrong. There's no inherent meaning in objective science. Certain behaviors might lead to happier people or animals or plants or whatever, but who says people matter anyway? We could be coincidentally here, and if earth gets destroyed and we all die, oh well. So, what does it matter if we all kill and abuse each other to begin with? We don't want to do that too much, if social coordination promotes propagation, but it doesn't affect things being inherently right or wrong. If there are really such things are right and wrong, then there's some unchanging standard at the core of existence on which to base things.

Anyway, just having fun with these matters. I'm a fairly orthodox Latter-day Saint (Mormon), so it's not too hard to guess where I am on matters. But I still think it's worth considering different aspects of God when people discuss central matters, especially of God's existence. I've hopefully also raised enough matters to show it's not easy to say that logically the answer must be so-and-so.

Also, I'm sure that folks more familiar with classical theology or philosophy (from any part of the world) probably know more official terms for all of this. I'm not well versed in such things.

English translation for "Placentero nos es trabajar"

As a missionary in Guatemala in 1995-1997, I wrote an English translation of the popular Spanish LDS hymn "Placentero nos es trabajar". This version is as literal as I could figure out how to make it while retaining rhyme and meter. I have to admit that even using recent Internet information, I have some trouble finding even the best translation ignoring the musical concerns for a few parts, but I've done my best anyway. The version here is updated some from my original effort. I'm actually working from memory right now, so it might vary some even from previous versions.

There seems to be some additional background on the song here and here.

Anyway, I hope this turns out to be of value to someone someday:

In the vineyard of Jesus our King,
Working hard is for us a delight,
And in honor we'll preach and we'll bring
To his people his law and his light.
For his light, for his light,
In the vineyard of Jesus our King,
For his light, for his light,
We will die in his work as we sing.

Listen ye to the word of the Lord,
With the loy'lty and fervor thereof,
And fore'er in your hearts do record
All his purity, truth, and his love.
With his love, with his love,
Listen ye to the word of the Lord.
With his love, with his love,
Take ye hold of the banner of God.

Oh, dear brothers and sisters, farewell,
For the moment to go now impends.
If in God we by faith persevere,
Past the veil we shall still meet again,
Meet again, meet again!
Oh, dear brothers and sisters, farewell!
Meet again, meet again.
With our God in his love we shall dwell.
 

Apple's Swift aimed at lock-in?

Well, the programming world's abuzz with Apple's announcement of their new programming language Swift. In their developer docs (not the iBook, since that's more effort to access), it says:

Swift is a new object-oriented programming language for iOS and OS X development. Swift is modern, powerful, and easy to use.

With no hint of open source, I suspect they truly mean "for iOS and OS X".

So, while it looks like a nice language, both in large things and small (though I don't agree with all their decisions), there's not much point in this language except for those already firmly in the Apple camp. This very nice system seems aimed squarely at making Apple developers more firmly just Apple developers.

And I distrust Apple as a corporation. Whatever prior art exists, I fear they'll have patents to dissuade 3rd-party implementations, unless they decide cooperation is in their business interests. Nice as it is, I guess I won't be touching it, unless Apple at some point makes a policy about being open with it.

Too bad. Though I do hope they prove me wrong sooner than later.

At least many other good options are already available.

(And on the topic of needing to be nice, I'm really just trying to say the issues that matter to me here. And I really would love Apple to prove me wrong.)

I should be nicer

I just realized my last two posts were in judgment of other people. That's not very nice of me, whatever I believe about the issues involved and whether or not anyone ever reads any of this. I apologize, and I should do better than that.

Bill Nye vs. YAGNI

So, here's a famous video of Bill Nye refuting himself:

Why do I say this? Well, he sets it up himself. The US is very successful at innovation despite a lot of people here disbelieving evolution. I don't know what percentage of successful innovators have which belief systems, but this presumed dichotomy exists in our nation.

A somewhat rational conjecture then is that you don't need belief in evolution to be able to innovate, at least in many areas. Even in areas where evolutionary or deep time matters do play a key role, there's perhaps no requirement for uniformity of belief in every aspect. There may even be scientifically testable hypotheses related to my conjectures. I suspect studies even exist, but this isn't my field.

Another way of saying this for me it is YAGNI. As in, belief in evolution isn't a key requirement for much innovation.

Meanwhile, Mr. Nye, you can have your own children if you want to teach them your world view. Or make more YouTube videos. Let me and everyone else teach our own children, too. And our children can also choose for themselves what to do with it. We have all kinds of various beliefs. That's freedom, rather than state indoctrination.

(Also note that I don't state my own beliefs about evolution in this post at all. They're irrelevant to my main point.)

Wolfram discovers OOP

Now, I'm probably being abusive here, but I think Wolfram is overblowing his value in his Wolfram Language announcement. When he says this:

In most languages there’s a sharp distinction between programs, and data, and the output of programs. Not so in the Wolfram Language. It’s all completely fluid. Data becomes algorithmic. Algorithms become data.

... I think this:

In contrast, the object-oriented approach encourages the programmer to place data where it is not directly accessible by the rest of the program. Instead, the data is accessed by calling specially written functions, commonly called methods, which are bundled in with the data.

... or perhaps even things like OpenDoc. He also sounds very Smalltalkish. I don't think he's talking Lisp-like code as data, but maybe he means that, too.

Saying "That there’s a completely general and uniform way to represent things" is also like saying "if S is a subtype of T, then objects of type T in a program may be replaced with objects of type S without altering any of the desirable properties of that program" (Liskov substitution principle).

Would Wolfram be the type to reinvent the wheel without full formal training in a subject matter? Um, yes.

I do love Wolfram Alpha, though.

Having algorithms is great, and for general web user accessibility, flexible language is nice, but when I want to be serious, I like a real programming language. And microkernel at that. Contrast Wolfram's statement that his "concept from the very beginning has been to create a single tightly integrated system in which as much as possible is included right in the language itself."

Hmm.

In more interesting news, Ceylon 1.0 was released a few days ago.

Steam Controller and app stores

Response to the Steam Controller varies a lot. I have a hypothesis on it.

First, why Linux and SteamOS? Windows 8 isn't such a disaster for games as the Windows App Store (if successful) could be a disaster for Steam. Valve wants independence and revenue as much as any other company.

The controller has a stated purpose: "[bridging] the gap from the desk to the living room without compromises." I think there's another one.

On some site (sorry, forgot which), I saw a comment claiming that there is no battle for the living room but rather that the battle is in mobile. I haven't looked up market sizes, but Sony, Microsoft, Apple, and Google all have at least some belief in the value of the living room.

However, mobile is an important space. We see Microsoft betting their reputation on this.

What can Valve do here? Android is as open as Steam Machines will likely be. Do they dodge Android because their focus is serious gaming? Yes and no, I think.

They care about the serious gaming segment, but they've also already lost on iOS and Android. Apple and Google already have app stores. Steam can't compete there. That's what they want to avoid with Windows. They want Steam to be its own power.

This is where the screen on the Steam Controller comes in. I don't think on its own it will be much more exciting than the Wii U GamePad's screen is. It competes with the main display. However, if the Steam Controller is hackable (stated goal by Valve), surely some people will make games just for the controller. And if the controller is a success (open question), that might become meaningful.

If the Steam Controller succeeds, it provides a rich IO platform that might possibly become a successful mobile platform of its own.

Yes, this is a crazy hypothesis, but it allows an avenue for Valve to move in this direction without making it a major immediate focus. Having future options might not hurt.

Nostalgia

Pandora playing "Rhythm in the Pews" by Ray Lynch on "Deep Breakfast" just pulled my heartstrings out.

No particular story, but it totally dropped me right into the middle of high school.

So many miles and years from there.

Palantir Eclipse TypeScript

Among other languages, I've toyed some with TypeScript over the past half year or so. Lack of good IDE for my use case (Eclipse, not VS) was lacking. But now a company called Palantir has been working on a decent TypeScript plug-in for Eclipse.

Hurrah!

I think I'm more in line with TypeScript than with Dart, and last time I tried the Dart editor (in the past month or so), it kept using high CPU all the time (maybe related to issues like this, not sure), and it was slow and flaky for its inference and code editing support. If JS really has speed limits that Dart can break, maybe I'd change my mind. Or if the Dart editor actually got any good. Don't know. For now, though, I like TypeScript better. It seems more "the right thing" to me.

Now if only Microsoft would add operator overloading to TypeScript and if someone would implement a TS to C++ compiler with full instant support for header parsing (pipe dream, maybe), I might really be able to make TypeScript my real go-to language. I'd prefer different, but it might be good enough.

As an aside, I'd really like this TS clone problem to go away, too. Even if it's a GnuTLS issue, it's only hit me at CodePlex so far as I know.

Mirror neurons and reusable APIs

One topic in neuroscience that gets a lot of attention in recent years is the "mirror neuron" thing (see here, here, or here). Decades ago, Rizzolatti et al. discovered that certain neurons would fire whether the subject was performing a relevant task or just watching someone else perform the same task.

Lots of fun discussion exists on the meaning of this.

My quick take is that it at least suggests modularity in the brain. If I developed a well-factored software API for handling any task of any sort (really, speaking of any half-serious software here), I would build reusable functions to support various aspects of the system. That's just expected, right?

Well, say I have some code paths using helper functions that actually do visible IO (say to a database or a web page or a robot arm or ...), the same helper functions would also likely get used in other contexts.

Drop a trace of some sort in said helper function, and you'd see it being used whether for visibly active things or not.

Mechanics and various use cases aside, that seems clear to me what is happening in mirror neurons. Much of the research exists around "what specific use case would these reusable functions have" and that's definitely interesting, but to me, the core is that reusable modularity is going on.

In a bit more searching, I also just learned that relevant term sometimes used in neuroscience is subserve (or subserving).

Dart: Static or Dynamic?

Dart Language folks just announced plans to make reflection more statically analyzable. Full-core reflection makes optimization hard. Yes, I believe that.

So, what does it mean to be "dynamic and proud of it"? To "take full advantage of its dynamic typing" means simple static analysis isn't so easy. Are there are specifically indicated advantages to dynamic typing that they actually claim anywhere?

And the current Dart VM doesn't get anywhere near Java for performance, despite claims that type checks don't help. Maybe they just need more time to optimize the VM? And as for producing tight JS, I suspect enforced type checks would avoid the need to whole program analysis.

Is Dart trying to get the worst of both worlds? More difficult optimization? Slower performance? No dynamic tricks? An unenforced static nominal type system with runtime structural typing?

I only casually observe Dart, so maybe I'm missing something, but I'm not sure they know their target.

On the other hand, I had been dismissing Microsoft's TypeScript for a while, but tried it out this past week. No Eclipse love, but TypeScript actually does a good job of providing the JS we already know but with a static analysis system (and no Dart-like fear of that "inference" word) that's adapted to existing JS usage patterns. It's pretty good.

Rust compiler speed

I haven't tried out Rust for several months, but it's one of the languages I watch as something I might use someday. A recent discussion of compiler speed as a lower priority worries me somewhat, though. That's one of the priorities I feel Go gets right. Go gets other things wrong in my opinion, though. Hrmm.

Compiler speed on Rust is somewhat blamed on Hindley-Milner-ish type inference, by the way. They feel that's important.

Defeating Gnome Evolution

Once upon a time, I apparently imported my Google Calendar info into Evolution, thinking the integration would be a good idea. It drives me crazy. The web interface is good enough.

Sad thing is, Evolution wouldn't let me delete the calendar. I searched for solutions, and nothing worked.

What did work was this (and maybe some of this is overkill, so don't sue me if you lose something you want):

1. Kill all evolution processes. I needed sudo for the calendar one, and that's probably the one that really mattered.
2. Kill the goa (Gnome Online Accounts) process.
3. Watch out, because evolution processes like to start back up on their own.
4. Delete .config/evolution (although maybe just the related sources files would have worked).
5. Delete .config/goa-1.0 (and again, maybe could have been more selective).
6. Delete .cache/evolution (and again, maybe could have been more selective).

After all that, if I logged out and back in or otherwise let Evolution restart, it no longer tried to access my Google data.

Anyway, it felt like virus hunting I've done in the past on friends' computers. Things just kept coming back. Is any "robust" software like a virus? At least to me in this case, Evolution was serious malware.

Again, this isn't a scientific report. Just vague notes on what I did. Don't blame me for anything.

Intelligence as a wave

On the side, I've been pondering self-modifying code as it relates to artificial general intelligence from a self-programming perspective. I think, in the extreme, an agent could (attempt to) change any aspect of its world, including its own software. To a great extent, humans are malleable, too, with cells dying and regenerating and with neural connectivity changing over time. I believe in spirit, too, but I don't know how everything works.

Anyway, I've wondered what it means for a running process (on a computer) to have access to change all its own software. If the code changes, and if all other aspects of memory change, during run time, what is constant?

I've started to think of it like waves. In a wave, the matter doesn't move, even though the wave (the energy) does. In a running process that can everything about its own memory and code, the software itself isn't the true process. The software is like the matter than the process lives in, and the process itself is some sort of wave in that medium.

Those are all my thoughts for now. Nothing formal. Just wanted to get them down in case I forget about it later.

Prezi's UI changes

I've never really used Prezi myself, but my son has for school. I just got a notice that they've changed their UI. That link probably won't last forever.

Summary is that they are changing from an organic look with things spread out in somewhat hand-designed fashion into a more common style with everything across the top (and looking a lot like recent Google UIs, too).

I think there are pros and cons despite their simple claim that "Our new interface is simpler, cleaner and better." There were reasons for the old UI, I think. They weren't just drunk. However, it is yet another example of an oddball interface made to conform to common expectations.

Long ago, I worked on a WYSIWYG HTML editor that went through the same kind of evolution.

What's common often is what's easier, especially when you want to grow to new users.

Wikipedia's efforts to be legitimate

Am I the only one annoyed at all the "doesn't follow guidelines" notices on Wikipedia pages? It's clear they want to be a "real" encyclopedia, but I think they are losing the value I want from them in their efforts to do so. I'm been somewhat okay since I've usually seen only threats to delete pages.

Well, today I found a deleted one.

I do scientific research for a living. I get the idea of standards and all such whatnot.

Still, I want what Wikipedia was, not what it has become. There are alternatives, but it's an issue of fragmentation. Maybe a simple, consistent, persistent place for collaborative sharing on any topic is just an unsustainable and unrealistic thing.

I mean, really, I can decide if I trust references. Allowing sidelined expert comment on legitimacy might be okay, too, but their current strategy is directly impacting what value I can get from them.

I've finally contributed (financially) a bit to Wikipedia a couple of times in the past year or so, but I think I'm going to stop. They more often aren't what I want, and I'll just have to accept that I need to look elsewhere. If they can't afford to stay in business, I'll already have learned to survive without them.

Favorite software: Which language?

Just a sampling of some of my favorite software or at least ones which I use frequently out of choice, along with their primary development language(s) so far as I understand things off the top of my head. These are in alphabetical order (if I don't make a mistake in manual sorting):

Bullet: C++
Chrome (including V8): C++
Eclipse: Java
Firefox: C++
Git: C
Gmail: JavaScript (front), ? (back)
Google Calendar: JavaScript (front), ? (back)
Linux: C
LLVM: C++
Skia: C++

There are probably other things I should have on that list, but it's a bit C++ (and C) heavy right now.

Maybe C++ is used because of inertia. I know it's far from ideal. It's a mess even, but it's clearly capable of being used for making good software. Something worth musing in my lifelong quest to find how I want to code.

C++: Why or why not?

These days, I'm most integrating with native libraries, although web browsers are interesting, too. (See perhaps NaCl and Emscripten on the latter.) Some of those libraries export C APIs. That's nice for reuse across languages. Some (Bullet, Skia, ...) do best with the raw C++. This makes interfacing more difficult. One of the best ways to use C++ libraries is to code in C++.

And truth told, especially with C++11, I don't mind coding in C++ myself these days. I like type inference and closures. Bothering with shared_ptr, weak_ptr, and unique_ptr isn't the end of the world, and it gets most resource management done. Eclipse CDT has passable (although quirky and not always reliable) support. On a fast CPU, I can almost survive compile times.

On the down side, C++ is still a complicated beast. I'm not sure I'd like to see results of newbie code in C++ as they try out fancy features (which sometimes really are needed for clean code, too). I also don't understand everything myself. I get the point of C++11 move semantics, for example, but I don't really understand how to use it. I'm sure I could, if I spent time on it, but I sort of hover around "I need to get to that someday" mode. And it's such a bother to have to understand such details. Many other such examples exist in the beast.

Also, there's the issue that I'm really tired of needing to declare functions before defining them and the whole header vs. source files. It seems a small thing, and I could argue their virtues, but it's one of the things I'm most tired of.

In the end, for just getting a job done when I need to integrate, I think C++ is the easiest way to go, and it really is possible to write clean and portable code. However, the warts and slow compiles really grind on me. I'd also like a good implementation I could use everywhere, open standards not withstanding. Maybe that'll be Clang someday, if Windows coding support goes up. Maybe.

I wish the language in my head would fly out automatically with amazing C++ integration support included.