Swift Protocol-Oriented programming

Apple makes a big deal about Protocols in swift and how they are better than anything else ever.  I found it quite irritating that nowhere in their explanation of what makes them so great did they mention that a protocol is eerily similar to an interface in Java.  Moving from a C++ background to Java, I was completely baffled why you would use an interface rather than an abstract class.  That question was answered back in 1997 when I started designing applications and APIs using interfaces first.  Nowadays, moving into swift, protocols certainly have features that interfaces do not - such as extensions and conditional conformance - but really - this is not something they just pulled out of nowhere.  I wish they didn't have to act like every thing they do is new and unprecedented.

It would be so much more honest for them to come out and say, "In designing a new language, we looked at what works in Java, Lisp, Python, (gasp) Perl, Haskell, Go, JavaScript - the needs of iOS and the environment apps find themselves in - and created a best-of-breed language."

Swift 2.0, Reference and Value Types, and Unintended Sharing.

I have recently begun learning swift 2.0, because I would like to build an iOS app and I really don't want to have to learn Objective-C.  I am trying to learn it the right way, which means understanding how the language works and not just mutating examples to learn by accident.

I have been reading a lot about structs and classes, and the difference between value types and reference types.  In short, classes pass around object references and structs make copies whenever you pass them around.  I visualize it in old-school terms:  Classes use pointers, but with structs the variable IS the data.

This seems pretty simple - especially if you are comfortable with object languages.  I have watched a few Apple videos, though, and they make it sound revolutionary.  This one in particular goes on about unintended sharing - I pass a handle to the same object into two different contexts where they are expected to be independent.  Change one, impact the other, etc.  His illustrative example was "I created a thermostat object, assigned it to my house.  Then I set the thermostat in my oven to 450, and my house caught on fire!"  Paraphrase.  Gag - what a juvenile way to introduce a language feature.  They could have at least used a real-world scenario they came across implementing their standard libraries that made this feature such a deal-maker.

This seems to me to be very valuable to a college student, or someone learning an object language coming from C, but really, is this that big of a deal?  I can honestly say that I haven't had a bug of this type in my code, that I have detected of course - for decades.  On the other hand, I just spent an agonizing couple of days trying to figure out why extremely routine code did not work.  Take this example:

var map = [String: [String: String]]();

var subMap = [String: String]();

map["map"] = subMap;

subMap["1"] = "2";

For those who don't know swift, this means create a map which can hold maps of string value/pairs.  Next, create a string value/pair map, and assign it to the key "map" in the top-level map.  Finally, assign the key/value entry "1" -> "2" into the sub map.  The expectation being that it will be reflected in the top-level map as well.  This is pretty standard in Java - I do it a lot so I can factor code which handles the sub trees into external code.  In this case, it doesn't work.  Because collections in swift are structs - I.E., value types - the assignment on the third line makes a copy which is unaffected by the assignment on line 4.  I came up with this working code after much hair-pulling:

var map: Dictionary = [String: [String: String]]();

map["map"]!["1"] = "2";

And only later uncovered the reason that I explained before.  I find this extremely annoying, but certainly manageable once you understand the language - and maybe even something you can use effectively.  But I found his example so contrived that I basically checked out.

Java FX Event Thread vs AWT Event Thread Brawl

So, I recently started working on a Java UI application focussing on my backend first, then the UI components.  I am not very good at making pretty swing UIs (very out of practice - but I was really active when Swing was in development - what was that, 1997?  :| ).  I have done a lot have dynamic web development over the last decade and am frankly shocked that swing UIs are so far behind.  A dynamic swing UI to match a trivial web interface would be a LOT of work.  So, my first cut at my UI was targeted at behavior and testing, which was a substantial effort - I would have thought automated unit testing in the user interface would be in a better state than it is.

Almost every substantive UI testing platform appears to be abandoned (uispec4j, abbott, others I can't remember anymore) so I decided to build my own support as I needed it (Not building a generified UI unit testing framework - just what I needed).  The one good thing that came out of this approach was I realized testing the UI through the UI - as a user would or a record/playback testing method - was a big mistake.  I was decomposing my user interface as any good developer would do, but my testing was completely monolithic.  Instead, I started testing components at the finest grain and my tests became so much faster and easier to write with less bulk.  I also wired components together to rely on messages between objects rather than having handles to each other.  Sound familiar?  That should have been my approach from the start.

At any rate, I was going along, and decided it was time to make the user interface better, and I thought it might be time to look at Java FX.  One of the major factors was Oracle choosing FX as the future direction for java, but also the ease with which you can externalize the building of the user interface into fxml files.  That is huge.  I can use a builder and not be tied to a tool like eclipse or IntelliJ - big win.

I made a refactor which permitted me to transition from swing to Java FX as it seemed desirable, and even encouraged with the addition of JFXPanel.  This seemed ideal since rewriting the entire UI all at once sucks.  Well, this sucks worse.  The Java FX Event thread and AWT Event thread are entirely incompatible - so threading in the UI is a nightmare.  Consider as an example a Swing Button action handler which needs to update the state of an FX node - you would have to do that asynchronously, you can't call PlatformImpl.runAndWait from the AWT event thread - it will hang a lot of the time.  But if your button action handler needs to wait until the FX node is complete updating - such as if the update triggers another event handler - you have to do it all asynchronously with a lot of calls back and forth into the different event threads and you are left with a real mess.

To compensate - I have had to convert all messaging in the GUI to asynchronous - which makes unit testing a major hassle because obviously test code needs to wait until things are done before making assertions.  The bottom line to me is not to do this.  Transitioning to Java FX should be done at least at the Frame level - or Stage in Java FX parlance - and don't let messaging in the GUI depend on passing between the different systems.

Maven dependency ranges must die!

When I first read about the capability of maven to loosely depend on an artifact using version ranges, I thought, "Wow, that's pretty cool!  Why doesn't everyone do that?"  After all, who wouldn't want the latest version of newly released awesomeness?  By way of example, this is how a dependency in maven usually looks, excerpted from Stefan Birkner's excellent JUnit system rules project:

<dependency>
<groupId>com.github.stefanbirkner</groupId>
<artifactId>fishbowl</artifactId>
<version>[1.1.1]</version>
<scope>test</scope>
</dependency>

This means your project depends on version 1.1.1, exactly, of something known as fishbowl in the group of things known as com.github.stefanbirkner.  The brackets around the version number are not usual, and are in fact redundant since they specify the same thing as <version>1.1.1</version> - that version and that version alone.  Going on further in the pom, we find this:

<dependency>
<groupId>junit</groupId>
<artifactId>junit-dep</artifactId>
<version>[4.9,)</version>
</dependency>

This construct is altogether different.  It specifies a dependency on the artifact known as junit in the group known as junit, but allows for any version greater than or equal to 4.9.  The bracket on the left is an inclusive operator and the parenthesis on the right is an exclusive operator.  The comma allows for any later revision.  By way of example, (4.9,5.0) would mean any version after but not including 4.9 but before and not including 5.0, and (4.9) would mean any version greater than and less than 4.9.  That wouldn't work at all.

This seems pretty powerful, but . . .

I have recently come 180° in my thinking about this.  I now hate them with a passion - for two very good reasons.

Awesome Reason I

This one is purely idealogical, which is not to say that it is without merit, it's just a caveat that it may be debatable.  If you depend, for instance, on apache commons-io 2.3, what reason do you have to expect it to work with 2.4?  Or even 2.3.1?  What assurances do you have from that developer community that 2.3.1 will not introduce a bug which impacts your library?  Certainly by version 2.4 the API might change and break compatibility with your code.  This is unpredictable and should not be part of a stable, release build.

Awesome Reason II++

This one is the biggie, and also exceedingly pragmatic.  The aforementioned system rules library, which while otherwise awesome, includes a dependency on junit 4.9 and onwards.  In a practical sense, though, depending on system-rules exposes my builds to periodic failures that are very difficult to track down or diagnose.  Just today I got this error again:

[ERROR] Failed to execute goal on project ssc-cli: Could not resolve dependencies for project org.bitbucket.bradleysmithllc.star-schema-commander:ssc-cli:jar:ssc.1.C: Failed to collect dependencies at com.github.stefanbirkner:system-rules:jar:1.9.0 -> junit:junit-dep:jar:[4.9,): No versions available for junit:junit-dep:jar:[4.9,) within specified range -> [Help 1]

What does this mean?  Why is it happening?  Well, after being plagued with this for a long time, I finally tracked it down.  Some transitive dependency of my project keeps retrieving crapped-up versions of junit, in this case 4.11-beta-1, which satisfies the dependency to be greater than or equal to 4.9, but is not an actual release - it is something that made it to central and then somehow into my repository.  My only (reasonable) recourse is to go to my local repository and delete the junit group tree (~/.m2/repository/junit) and rebuild.  Guess what happens next?

[ERROR] Failed to execute goal on project ssc-cli: Could not resolve dependencies for project org.bitbucket.bradleysmithllc.star-schema-commander:ssc-cli:jar:ssc.1.C: Failed to collect dependencies at com.github.stefanbirkner:system-rules:jar:1.9.0 -> commons-io:commons-io:jar:[2.0,): No versions available for commons-io:commons-io:jar:[2.0,) within specified range -> [Help 1]

Yep, you guessed it - another broken dependency range - this time apache commons-io.  Repeating the same process, I delete my cached commons-io artifacts (~/.m2/repository/commons-io) and now my project builds.

I do not know why exactly this keeps happening - and I am sure that there are many things that could be done to fix it - like track down bad dependencies and fix everyone else's poms, but that isn't an option in most cases nor is it even something I want to do.  My project has an explicit dependency on junit 4.11, which satisfies >= 4.9, so I don't know why it would consider any other version.  The bottom line is that there is no way to predict when a library will break compatibility with yours, and you should not try to anticipate when that will happen.  Builds must be stable and reproducible, and dependency ranges violate both of those goals.

Snob overflow . . .

Okay, another one of my many pet peeves. When people ask questions to Stack Overflow, the community often incorrectly assumes that you are too stupid to ask a real question and instead talks down to you and won't give a straight answer, even if there is one.

Here is a case-in-point: how-to-release-all-permits-for-a-java-semaphore

The question was immediately met with contempt: "What do you need this piece of code for?". This question was not asked for clarification, but so that the discussion could go in a completely different direction. The Stack Overflow moderators are such Nazis about intervening: "This is not a question!", "This is a survey!", "These are opinions!", "This is a duplicate!" - that I am surprised they don't get upset in this situation, because you have a clear question posed, and the selected answer goes in a completely different direction. Rather than answering the question "How to release all permits for a Java Semaphore", they answered the question "How do I better design my code to keep my thread pool in sync?"

The simple answer is:

semaphore.drainPermits();
semaphore.release(totalNumPermits);

Again, whether that discussion is valuable or not, it does not answer the very straightforward question that was asked.

Sonic, What's up with your foam cups??

I have been noticing for the past few months that my Route 44 styrofoam cups from Sonic in OKC have the annoying 'feature' that they leak through the pores in the foam. I have noticed this many times - and is it ever annoying. Here is a sample from the cup I am using right now. This cup is probably two or three days old, picked up at the Bricktown Sonic:

Those little drops look like normal condensation, but they are actually water escaping through the cup. I have to keep a paper towel under my drink at all times or else my desk will be all wet. In years past I could keep the cups for a long time and this would not happen. Very strange and not a little annoying.

Java Synchronization. What's the big deal?

Throughout my career as a Java developer, I have read a non-trivial amount of code related to minimizing the impact of synchronized code blocks.  The topic of thread safety is extremely complex, and must be embarked upon carefully.  In some cases, just declaring lack of thread safety can simplify a project immensely, E.G., java swing, but there are times when it can't be avoided without introducing a lot of complexity on the other side of the API.  That's not what I am referring to, however.  Consider double-checked locking.  This technique is often used simply to reduce the amount of time it takes to call an accessor.  To illustrate, I wrote the following chunk of code:

import java.math.BigDecimal;
public class Main {
 public static final long TEST_COUNT = 1000000000L;
 public static void main(String[] args) {
 long r = 0;
 long startSync = System.currentTimeMillis();
 for (long i = 0; i < TEST_COUNT; i++)
 {
 r += getSync();
 }
 long stopSync = System.currentTimeMillis();
 long startUnsync = System.currentTimeMillis();
 for (long i = 0; i < TEST_COUNT; i++)
 {
 r += getUnSynch();
 }
 long stopUnsync = System.currentTimeMillis();
 BigDecimal syncTotal = new BigDecimal(stopSync - startSync);
 System.out.println("Sync took (" + syncTotal + ") ms., or (" + (syncTotal.divide(new BigDecimal(TEST_COUNT)).multiply(new BigDecimal(1000))) + ") microseconds average.");
 BigDecimal unsyncTotal = new BigDecimal(stopUnsync - startUnsync);
 System.out.println("Unsync took (" + unsyncTotal + ") ms., or (" + (unsyncTotal.divide(new BigDecimal(TEST_COUNT)).multiply(new BigDecimal(1000))) + ") microseconds average.");
 }
 private static synchronized long getSync()
 {
 return System.currentTimeMillis() % 100L;
 }
 private static long getUnSynch()
 {
 return System.currentTimeMillis() % 100L;
 }
}

When I ran it, this was my output:
Sync took (98345) ms., or (0.098345000) microseconds average.
Unsync took (43530) ms., or (0.04353000) microseconds average.

The difference here is 50 or so nanoseconds per access. Unless you are writing a high-performance application like a 3D game or database, I just don't see how this can even be worth discussing. Almost every application I write would involve calling these accessors on creation, which means 40 or 50 times during an entire application life, or even if it is tied to user requests like in a service or web application, 50 microseconds per request will be dwarfed by the amount of time the request itself takes. If there is a database access, just opening a connection that takes 1 millisecond to open will be 20,000 times slower than a synchronized accessor.

As engineers we sometimes like to focus on the really fun stuff, like generated bytecode or network packets or even CPU states, but synchronization overhead doesn't even seem like it's worth the time to type out.

PS: Have I said how much I hate the blogger editor???