Trends with Low Powered Clients [Tablets, and Smartphones]

Recently there has been a push to replace desktops and laptops with low powered machines. These machines have taken the place as mobile devices [phones], tablets, netbooks, and with some ambiguity ultra books. These machines claim to push the responsibility of major processing onto server environments [the cloud], and leaves the visual tasks [GUI, localization, collecting user requests] up to the client. If you believe the marketing hype….

Recently there has been a push to replace desktops and laptops with low powered machines. These machines have taken the place as mobile devices [phones], tablets, netbooks, and with some ambiguity ultra books. These machines claim to push the responsibility of major processing onto server environments [the cloud], and leaves the visual tasks [GUI, localization, collecting user requests] up to the client. If you believe the marketing hype….


The advantages to the user is the biggest draw of the trend. The user is able to purchase a cheaper piece of equipment, and tends to have a lower cost of ownership. Although the environment may lock the user down to what software they may install. Low powered machines tend not to take up as much physical space, and give a longer battery life.

Before I go on a huge rant, I must concede that the whole tablet/smartphone trend has made it cheaper and easier to create portable generic devices. Instead of purchasing a small novelty devices, you can get an application that does the same thing. Soon in the future, hipsters will be bragging about how they still use a desktop alarm clock, because its retro.


Despite the trendiness of tablets and smart phones, this is pretty much the whole “thin client” fad all over again. Most of the work is pushed to the server, and the thin client must have access to the server to work. Despite the marketing, network issues have not been resolved with tablets and netbooks. Cellular modems have been added to the devices [3G, HPSA, and LTE], but they tend to have issues with coverage, network saturation, providers/governments willingness to jam signals, and latency. Even with WIFI tablets, a network isn’t always guaranteed.

Another annoyance that comes with the low powered devices, is that the user lacks the choice of operating system. Due to non-Intel compatible processors and locked down BIOSes this makes things difficult. The user is locked down to the platform that is installed. It’s kind of a benefit as that the device can update its-self. However, applications can be rejected from the marketplace/application-store.

Sub rant: A tablet makes it incredibly easy to navigate and read web pages. However it becomes very difficult to perform any task that has any merit. The onscreen keyboards and autocorrect tend to impede or prevent the task from being performed. One has to have a Bluetooth keyboard if they wish to type anything longer than a text message on a tablet. Additionally the ability to select something with precision is lost on a touch enabled device. Although, one can pair [Bluetooth] or plug in [USB] a mouse and use the mouse pointer on android.

What does this have to do with development?

Sadly, this is being pushed to developers as being the “hot new thing.” Its being treated as something that has never existed before, if you believe the job listings. It seems like everyone wants an IOS/Android application, wither its relativant or not. Apparently, the world of Windows CE, QNX, PalmOS, and embedded version of linux are pretty much ignored.

It appears that the push for an application market place is pushing the application as a service idea. It’s great for the user, outdated versions practically become a thing of the past. This is unrealistic for anything but novelty and open source applications. Applications will be expected to be supported, maintained, and cheap [to compete]. I may not be a business major, but this seems unfeasible as a business. You can’t sell a jug of milk and provide free refills for life.

Another concern for developers is the cloud/traditional services that will be provided to the mobile. Given the specifications of the devices, and the current models for services [XML based], providing an efficient delivery model for mobile devices. I would change my opinion on this issue if binary services were used for mobile devices. It would also be nice if the services were switchable, depending on the client device. [XML/YAML/text based for desktops, binary for mobile devices]. This would be slightly more tolerant for the network needs of mobile devices.

What I believe isn’t possible with “The Desktop Killers” (Tablets and Smart Phones)

  • Professional Grade Photoshop-like Applications
  • Real-time, low latency high end graphics rendering [rendering on a server farm will kill the latency]
  • P2P Software
  • Multi-user space on the device [currently the mindset is tied down to 1 device, 1 user at a time]
  • True background services/notifications (its more of a hack right now, this is impeded by power saving and modem [WIF, Cellular] usage) [Examples: monitoring applications, IM applications (where the user may not actively be using their device)]

CrossOver Linux Professional

I’ve been using  [Gentoo] Linux as my primary OS for quite a few years now. I like it. It helps me work, the way I want to work. The only downside to being this committed to using Linux is the lack of a good office suite. Yes, there is LibreOffice, KOffice, and was OpenOffice. However, from my experience those don’t offer nearly the nice experience that MS Office does.

This is where Crossover Linux comes in. I hate sounding like a marketing tool for a company. But this is a product I’m glad I paid for. It has saved me many headaches. Crossover Linux is a tool that basically turns Wine into apt-get/portage/yum, but for Windows binaries. On top of that, there is the support and innovation that wine doesn’t give you right out. Without Crossover office, to install MS Office you’d have to modify your wine environment many times, grab and install the dependencies in a sorted order, and then finally try [and possibly fail] at installing MS Office. That was depending on which guide you’re looking at. With Crossover Office, to install MS Office just open the wizard to install software, create a new bottle, and tell it that you’re installing MS Office, provide the installer files and it does all of the hard work for you. Crossover even finalizes the install by setting up the nice menu items in the K menu, and in your file manager.

Another neat feature that it has is bottles. Basically it creates sandboxed environments for each application. You can have your Steam install files separate from MS Office, or WoW files. Yes, I did say it runs steam. CrossOver office is just $50 for 6 months of free upgrades, and you get email support.

If you want to save quite a lot of time, and remain productive on Linux, get this product. Lastly, by supporting this company, you support their effort to give back to the Wine project. Their employees regularly release their changes back into the Wine project.

What Have I been up to lately? Erlang, Scala, Clojure, Ruby, IO, Haskell, and Prolog Oh MY!

What Have I been up to lately? 

Other than being busy with work, I have been reading and working through the exercises in “Seven Languages In Seven Weeks” by Bruce Tate. It is a book that goes through the following seven languages: Scala, Ruby, Prolog, IO, Conjure, Erlang, and Haskell. The amount of time needed to read through each of the languages isn’t seven weeks, but more like 3 days per language. Each chapter has 3 days worth of lessons and one day to “review.” If the reader wanted to go further in detail with one of the languages, there were suggestions and exercises to help the reader do so.


The biggest criticism about this book is that the book either skipped over or under-explained interesting features. For example, most of the languages consisted of Day One: Basic Syntax, Day Two: Lists/data manipulation, and then went to Day Three: Concurrency. There are a lot of concepts or tidbits of the language that could have been covered. If concurrency was one of the interesting bits of the language, make it a small section and prompt the reader to seek other resources.

I also wish that this book went over language-neutral concepts [introduced by the languages] before teaching the languages. It did try to wrap up the book by explaining the concepts, but I felt like it was too late by this time. Lastly, the book was great to introduce a person into the languages. However it left me with the feeling that it was something nice to know, but not something I could use in any of the projects I’m currently working on.

What I liked about the Book

I really like that the book went through so many different languages. Additionally, the book attempted to shy away from the traditional OO based languages, and stayed with the functional based languages. I was taught Prolog in undergrad, but I liked the introduction of a prolog. Prolog is an incredibly useful, and unique language, however it lacks the resources that the other languages have.

After the book I would like to follow up with the Erlang, Prolog [which was a refresher for me], and Haskell.  Clojure was interesting, however I didn’t get a strong urge to continue with it. I also thought that Groovy would be a little more useful than Scala.

The saying “Foreign Carriers are better than domestic” Sounds True until you try Lufthansa.

Most American’s claim that Lufthansa over all is pleasant, however the Europeans are jaded. I think the Europeans are on to something.

This is a blog post I’ve been putting off for a long time. Mostly, I’ve been putting it off to prevent this post from becoming a 10 page rant that absolutely no one would read all the way through. The length of just the outline is nearly 3 pages, so I’m sure that the actual length of my rant would exceed 15 pages. As an upfront disclaimer, I would like to defend my post admitting that I had no intention of disliking Lufthansa when trying them out.

To keep this post simple I’ll use bullet points of where I have been screwed over by Lufthansa: [And that you may want to consider when looking to fly with them]

  • Ticketing
    • E-Ticketing is kind of nice (although standard will all major airlines). They however, will not print your connecting ticket within the US. Thanks guys! That’ll make the run through O’Hare from terminal 5 to 1 even quicker. [That was sarcasm, in case you were wondering]
  • Check-In Agents
    • There is absolutely no “flat tire” rule at Lufthansa. The agents don’t care, and you are screwed. They don’t care even if the gate and security is directly behind the check in desk. [As it is in Tegal]
    • [This was told to me by an army member on the flight from Charlotte to Frankfurt]: Lufthansa charges service men/women extra for second and overweight packs when being deployed. The charge she was forced to pay at the gate was $400 on the spot for two bags. This is, from what she claimed, a waved courtesy provided by US Air.
  • Value For Class
    • Business: The short hops, this is more of a gimmick than anything else
    • Y-Fare Class: Also known as the “we completely screwed you over and we don’t care” class. This is not a refundable ticket. It doesn’t even guarantee service. If you are gifted by the “grace of the gods” [a.k.a. Ticketing people and their managers], you may be able to get a credit towards a rebooking (based on the estimated value of the ticket). This does not help you in times of trouble where you need to rebook a flight. Most typically when rebooking a flight, the flight cost increases and you must pay the difference.
  • Flight Quality
    • You’d think with the higher cost and “advertised premium value” however it depends on what flight it is:
      • Charlotte-Munich has a decent set of equipment and flight attendants
      • Frankfurt-O’Hare has one of the oldest planes I’ve flown with LH, and the surliest flight attendants that I’ve ever had.
      • On the surly flight attendants on FRA-ORD: Just after takeoff, my neighbor-across-the-aisle’s (a fragile 80 year old grandmother) bin came unsecured and the baggage threatened to fall out. I notified the flight attendants about this by signaling it to them. They refused to address it and signaled back for me to resolve the situation. Fortunately for the old lady, I have a soft spot for old ladies and prefer to see them uncrushed. I probably should have contacted the FAA about this.
  • Scheduling
    • My rebooking (of TXL-MUC-CLT) ended up being Tegal Berlin-Frankfurt-Chicago-Charlotte. There were 4 delays. The first delay was in Frankfurt to Chicago, the rest were the Chicago to Charlotte flight. One delay from Chicago to Charlotte, allowed me to actually get through security. This was not a fun 20-23 set of hours travelling.
    • The ticketing agent refused to put me on a star alliance flight until it became the last option [Chicago to Charlotte] – this despite mentioning CO97 was leaving only an hour later [direct to NYC]. The agent refused because it was not a Lufthansa-operated flight.
  • Baggage handling
    • On my rescheduled flight back my baggage was “lost” between Frankfurt and Charlotte. It made it back in Charlotte, however it would have been nice to know that the baggage was “priority marked” and I didn’t have to wait for it before going through customs.
  • Cost
    • For every flight path I’ve seen Lufthansa is always more expensive than any of the other carriers.
  • General PR
    • Their Facebook page congratulated a judge on dismissing the Frankfurt Air Controllers strike [due to pay demands]. So: the people that prevent planes from crashing on landing, and manage the planes in the air [according to LH] are the ‘bad guys’?
  • Customer Service After the fact
    • If you have an issue, phone support will not hear your complaint. They will tell you to complain online.
    • If you complain online, you’ll receive an automated letter that they are “experiencing high volumes” during the middle of the summer. (Really? There’s a red flag)
    • My first complaint was never responded-to, nor was my email to the CEO. The second complaint sent online referenced the first. This got their attention only 2 months after the second complaint.
    • When they respond to you they attempt to “appear sympathetic” by passively putting the blame you on by saying: “We’re sorry that you were displeased with the service” [Translation, it was your fault using our service go **** yourself] Then they come up with a crap reason why they don’t have to tend to your complaint, such as in my case the complaints were dismissed for the rebooked flight because the original flight’s checkin time was missed. Seriously? Basically you can pay $1500 extra [in my case] on top of the existing full fare ticket], and they aren’t responsible for the service?
  • Frequent Flier Program
    • Earning Miles
      • The main draw of the program is that it’s within the star alliance, but it’s extremely difficult to earn on their partners (without full fare tickets &/or long distance tickets).
      • Earning miles is based on the class of your ticket – which is typical, but the earning ability is rather crappy. Discounted tickets [E, K, L, T] are credited at  only 50% of the miles flown.
    • Spending Miles
      • Flights
        • You have to earn ~60,000 miles with Lufthansa [but have flown far more actual miles]. By this time you’ve pretty much have flown enough to put a major payment down on a house. Your reward is a round trip ticket from North America to Europe, with the cost of $700 [in a non-peak season]. Congratulations: you have just wasted all that money on flights, to get an award flight that you still have to pay a large percentage of the ticket. To compare with another Star Alliance carrier, United, the equivalent cost for an award ticket can be 60k miles and $120-200 on average.
      • Hotels
        • Last year I earned 26k award miles: I don’t plan on ever using this program again. I thought, hey I can get a free night stay. I go to look up the costs: For a non-peak area in Charlotte, it costs between 30k and 41k miles. That is the equivalent of 4-5 round trip trips to Germany for only a $120-160 night stay in a small city.

My flight experiences for travel from the east coast to Europe have been with American Airlines, US Airways, United/Continental, and Lufthansa. Each of the airlines I have flown the transatlantic route at least twice. With shorter routes [domestic and international] I have also flown with Delta, Southwest, British Airways, and KLM.

To summarize: Who would I recommend Lufthansa to? Wall street bankers? No: yachts and $100k+ cars sound like a better investment. Regular bankers? I’m pretty sure expensing that [on first class] is a bit of a stretch. (First class from San Francisco to Frankfurt was $20k when launched – that’s the price of a Toyota Accord.) Paid for by someone else? Not worth the stress or effort (trust me on this).

To get back to being serious, who do I think should fly with Lufthansa:

  1. People who are pleased with self harm
  2. People that I don’t like. I’m not talking about “I just have distaste”. I’m referring to an enemy for life situation here.

Too Long; Didn’t read? Avoid this lame flying duck.

Immutable Objects (Article 3 of 3)

This article is more involved with integrating java objects with existing frameworks than the structure/usage of an immutable class.


To use an immutable object with hibernate; the access-type must be configured to use fields. The default access type can vary upon usage. When a class file is mapped via XML, the access type is set to properties (values are retrieved and saved via the getters and setters). Under this condition set the default-access property [under the “default-mapping” tag] to “field.” If hibernate is configured to use annotations, make sure the @id annotation is positioned above one of the fields. With hibernate configured to used fields, the values will be inserted directly into the actual values. Note: Since the class is immutable, an update will never be needed for the class. The only possible operations that can preform with an immutable object are saving [insert], querying, and deleting.


JAXB is a recently included XML serialization library, it is often found in libraries dealing with web services. Its purpose is to convert an object into an XML based representation. It operates in a similar fashion as Hibernate, and requires a similar configuration.  To force JAXB to use the instance members, rather than the setters, use the annotation “XmlAccessorType” above the class, and set the value to XmlAccessType.Field.  Additionally, it requires a default [zero argument constructor], however that may (and should) be marked private.


Making immutable classes serializable is not as easy as it is with mutable classes. With mutable classes, implementing the Serializable interface [which has no required methods] is all that is needed. With an immutable class, this is not an option. One option to make the class serializable is to have the class implement externalizable. With the externalizable interface the developer must implement and manage the serialization functions. The second option is to create a serialization proxy, within the immutable’s class. How to create an serialization proxy is beyond the scope of this article.

Immutable Objects (Article 2 of 3)

How to define them

New Java developers may have gotten to this point in the article and started to pull their hair out. They’re asking “How would you create the object if there isn’t a constructor, and how would you define the fields if you restrict them?” Well the best way to define an immutable object is to use an Builder class, that is defined as an inner class to the object.

A builder is a class whose entire responsibility is to build one class. Typically, this is the responsibility of a constructor. However, there are situations where a constructor is not available, as with this, or multiple constructors may decrease a source file’s readability.

Finishing touches

Without application, immutable classes serve a very limited purpose. The next few sections will explain how to use immutable objects with various other frameworks/libraries.  A beginner may immediately jump to suggest adding the keyword final will solve the problem with immutability. This is incorrect, and depending on where the keyword is, incorrect.

If the final keyword is appended to the class declaration, the class may not be extended. If the keyword is on an instance variable the reference may not be changed after once being declared. If the instance variable is a primitive data type, then the value cannot be changed after the object is constructed. However, if the type is an object, then the content within the reference may be modified [if the object allows mutable access].  If the final keyword is before the return type of a method, the method cannot be overridden by an extending class.  If the final keyword is before a parameter, means that the reference may not be changed within the method.


For example, a class that exposes the reference to a Date field of the class may be modified outside of the class by using the reference’s setters. The date object’s main storage of data is based on a long variable. To prevent this from causing an issue in your custom types, non-primitive accessor methods should clone the reference before returning.

An example of this can be seen here:

Main Method:

public static void main(String[] args) {
   ImmutableClassicl = new ImmutableClass();
   MutableClass mcl = new MutableClass();
   Date immutableVar = icl.getToday();
   Date mutableVar = mcl.getToday();

   //Lets do something destructive

   DateFormatd form = new SimpleDateFormat();
   System.out.println("The Immutable Class returns: "+ dform.format(icl.getToday()));
   System.out.println("The Mutable Class returns: "+ dform.format(mcl.getToday()));


The  MutableClass:

public class MutableClass {
   private Date today = new Date();

   public Date getToday() {
      return today;

The ImmutableClass:

public class ImmutableClass {
   private Date today = new Date();
   public Date getToday() {
      return new Date(today.getTime());

Please note, there are no modifiers provided in both of the Immutable/Mutable classes. Without modifier methods, the developer should assume that the internal state is not accessible to be modified from the outside world. However, as one would expect this behaves a bit differently. The result of the main method is:

The Immutable Class returns: 10/9/11 9:07 PM

The Mutable Class returns: 12/31/69 7:00 PM

Immutable Objects (Article 1 of 3)


This is a three part series that takes an indepth look at the who, whats, hows, whens, and whys of using Immutable classes. This article assumes that the author can read/understand/use Java, and has some experience with object oriented development, and maybe design patterns.

What are they?

As their name describes, Immutable objects are objects that cannot be changed after creation. Once the object is created the internal properties of the object are resistant to modification.Typically the signature of an immutable object is: lack of setter methods, private constructors, the avoidance of shallow copies, and preference of deep copies during the creation or in the accessor methods (more about this later).

Why would you use them


Immutable objects, when coming from a “Java Bean” perspective, seems a tad frustrating. With Java beans one can easily modify a bean when needed and pass the result to another component. However with immutable objects, this is not possible. To modify an immutable object, after creation, a copy constructor, or a new object has to be created. This now creates 2 instances of similar, but not entirely equal, objects in memory. The creation of a new object takes up more memory for this new instance. If an object is guaranteed not to have been modified, or modifiable then you, the developer, can trust the data within the object not to be changed while you are using it. The primary benefit of this aspect is extremely useful for concurrency [threading]. Now, that you have an immutable object, there is no longer a need to lock the object just to read its value.

What problems do they solve

Immutable objects don’t solve a very visible problem. They won’t make your program perform new operations. The concept is more of a way of alleviating problems that are potentially in the code already, can enhance readability, provide more security and increase performance.  Since the object is assumed to be unchanged, code used to check for modifications [typically referred to dirty bits] is not needed. Additionally lock mechanisms would be eliminated [for reading the object, and technically writing to the object (since that’s not possible with an immutable object)].

Immutable objects are inheritantly more secure; objects are guaranteed to be unmodified. With a  modifiable object changes to the object must be validated when they are changed, and after the object has been changed, as opposed to immutable objects [where validation really only occurs at the creation]. Additionally, they are more secure because the creation of the object is the responsibility of another component, how this works will be discussed later.

Immutable objects can become performance enhancement. Since they do not change, the individual instances of the objects can be reused amongst different threads, processes [potentially], and applications without concern of modification of the program’s operation. Additionally with removing the need for locking surrounding the immutable object you can get rid of potential deadlocks and locking overhead. However, with the creation of new objects, one must be aware about the total amount of objects, and memory being allocated. Large amounts of allocations may provoke garbage collection, or worse, cause the application to run out of memory.

The Memory Argument

With exceptions to extreme cases, worrying about the memory usage [compared to using modifiable instances] is more of a sign of a premature optimization, than a reasonable concern. Some of the extreme cases are:  very small embedded systems [where available in KBs rather than MB/GBs], or prevalence in your application. If immutable objects are used for the sake of being used, then the benefit of the immutable objects are negated. A few examples include:  short life of the objects [the objects are being used only in a short scope and were never written to anyways], needless copying of similar immutable objects (but with a different instance). These abuses of the immutable object pattern can be corrected by using a flyweight pattern, and expiration, to create, cache, and prune the objects. The issue with small systems requires more thought, testing, benchmarking, and prior design before considering immutable objects.


One of the best benefits of immutable objects is that the creation of the object can be managed, and restricted. The creation of the immutable objects can be restricted to factory methods [within a flywheel]. This means that a caching model can distribute previously created objects, and create new requested objects on demand. By using the factory method and fly weight patterns, memory can be efficiently managed and objects can be better managed. Additionally, if the caching module usages WeakReferences, and there are not other usages of the object, then the unused objects would become a higher priority for the garbage collector to collect.

Additionally by introducing hashing, and reusing objects, you are able to get the benefit of having less object allocations in the VM. This, in turns, reduces the probability of the GC running, and needless objects from being created.

This article is continued here

Things I Wish Existed a Long Time ago: Unit Test Reporting

Reporting is, generally, one of the most boring tasks/subsections of Software Developments. The level of “uninterestingness” is exemplified by the “TPS” reports in OfficeSpace. However, reports can be awesome. They can be incredibly useful when they help you if they  accomplish your tasks, are interactive, and show data in a convenient/uncluttered fashion.

Unit testing is one of the categories that is absolutely necessary in development [even more so for larger systems], however the tools to scour these tests are often unhelpful. The tools that interact with NUnit, JUnit, GUnit tend to just reveal the results of the tests shown. Code coverage tools help, in reporting back the % of code covereed by the tests [and some times, with TestCacoon (C++), and EMMA/EMMA-compatable (Java) IDEs] However these tools lack an overall reporting capiblity to say “hey these bits/seconds/methods/components” lack the coverage the most in your code.

The only tool that I have found so far that will handle this is Clover [by Atlassian]. The features look great. Unfortunately, the product requires having a centralized build server. Which is a little too much to ask for hobby projects. [Speculation warning] To use this, it would require a continuous integration/build server setup.  Also, the cost maybe little high [$1200 for a 1 machine server] to make an off the cuff suggestion to management.I realize the return for a product may exceed the cost of developing a huge commercial product, however it is a little difficult to determine that [without the evaluation trial (if requires an build server and you don’t have one that’s a lot to ask for an evaluation)]. They do have an desktop version, but from the screenshots and the description, I wonder how well that would work [being a web client]. Also, I doubt that it includes C++/GUnit support.


Fixing Classpath Issues with JasperReports, J2EE, and Maven

If you are having issues with bundling JasperReports, a J2EE server, and Maven, you are not alone. There are many bumps in the road for getting JasperReports integrated with Tomcat/J2EE Container and building with Maven. Hopefully, this blog entry will make things slightly easier.

Firstly, there is the confusion of where the JasperReports dependency lies in the maven2 repository. There is a very suggestive entry for: {groupid: jasperreports, artifactid: jasperreports} however, that entry only hosts versions 0.5.0 to 3.5.3. The entry: {groupid: net.sf.jasperreports, artifactid: jasperreports} contains the versions 3.6 to the latest version. In addition, the last entry contains an artifactid of jasperreports-fonts, handy if special reporting fonts are requested from your reports.

Secondly, if you are getting ClassNotFoundException or NoClassDefFoundError for the class: net/sf/jasperreports/engine/JRException your issue with still with the POM configuration for JasperReports. The ClassNotFoundException is a runtime error, so despite a successful build, you will still see this. Despite the  jasperreports-x.x.x.jar file being in your web-inf folder, you may still see this error.

You must modify the scope of the component in the pom.xml. Change the scope from compile [which is needed to build], to “provided.” ( Provided not only uses the dependency to build, but update’s the container’s classpath to use this as a runtime dependency.

Continue reading “Fixing Classpath Issues with JasperReports, J2EE, and Maven”

Train Stations

Keeping to a similar topic as the last few posts, I thought I’d come up with a list of the train stations that I have got on a train at or got off. Passing through, or stopping for a break does not count. [For those overseas: Amtrak stops for cigarette breaks every so often] Secondly, I couldn’t let Warren outdo me with his trainstation list.

  • US
    • Durham (DNC)
    • Charlotte (CLT)
    • Washington DC (WDC)
    • Burlington, NC (BNC)
    • DC: China Town/Gallery PI
    • DC: Smithsonian
    • DC: (Amtrak/Metro) Union Station
  • England (All in London)
    • Terminal 4
    • Earls Court
    • Knightsbridge
    • Camden Town
    • Westminster
    • Waterloo
    • Notinghill Gate
    • Oxford Circus
    • Monument
    • High Street Kinsington
    • Tottenham court Road
    • Bond Street
    • Shepherds Bush
    • Victoria Station
    • Piccadilly Circus
  • Germany
    • Berlin: Alexanderplatz
    • Berlin:  Fredriedrichstrasse
    • Berlin: Hauptbahnhof
    • Berlin: Potsdamerplatz
    • Berlin: Stadtmitte
    • Berlin: Bundestag
    • Mannheim HBF
    • Munich: Marienplatz
    • Munich: Olympia zentrum
    • Frankfurt Airport
  • France (All in Paris)
    • Gard du Nord
    • CDG Airport
    • Gard Du Est
    • St- Michel
    • Assembly Nationale
    • Ecole’ Militare
  • Austria (All in Vienna)
    • West Hbf
    • Stefansplatz