Automatic reloading of web app sources in Ring

I’ve been wondering how to test out the librarian-clojure web application I’m developing with Ring and just stumbled upon this thread on the ring-clojure mailing list – What is the best way to run a ring application in REPL? in which James Reeves wrote:

“The ring-serve library should work the same way as “lein ring server”, minus the automatic reloading of modified source files.”

That was it! It made my day. I’d already been using lein ring server command (as described in Interactive Development), but didn’t even think it’d provide such a feature – automatic reloading. But hey, the aforementioned page says:

“When you’ve done that, you can start a new server at the command line with:

lein ring server

The server will automatically reload any modified files in your source directory.”

I’d bet I read it with a great care a few times – it turns out not carefully enough!

I ran lein ring server in a terminal and left Jetty/Ring/librarian-clojure up and running.

jacek:~/oss/librarian-clojure
$ lein ring server
2012-01-29 21:03:30.160:INFO::Logging to STDERR via org.mortbay.log.StdErrLog
Started server on port 3000
2012-01-29 21:03:30.161:INFO::jetty-6.1.25
2012-01-29 21:03:30.184:INFO::Started SocketConnector@0.0.0.0:3000

In another terminal I executed curl to see the output (I knew the tool as an alternative to wget, but it’s just a couple of days ago when I learnt the -X command-line option to test RESTful Web Services and it suddenly became the tool of choice).

jacek:~
$ curl -X GET http://localhost:3000
HELLO, WORLD

Should you want to experience it yourself, simply git clone the librarian-clojure project and follow the steps above. It’s really that easy.

I’d love hearing your thoughts about it. The upper-case function is my first attempt at, shall I say, a middleware in Ring which also helped me get familiar with the threading macro ->. I read and tested it many times, however it’s my first “production” use for something real. See core.clj in the repo.

(ns librarian-clojure.core
  (:use ring.adapter.jetty
        ring.handler.dump))

(defn hello-world [app]
  (fn [req]
    {:status 200
     :headers {"Content-Type" "text/html"}
     :body "Hello, world"}))

(defn upper-case [app]
  (fn [req]
    (let [resp (app req)
          body (:body resp)
          upper-case-body (.toUpperCase body)]
      (conj resp {:body upper-case-body}))))

(def app
  (-> handle-dump
    hello-world
    upper-case))

(defn -main [port]
  (run-jetty app {:port (Integer. port)}))

Ah, did I mention about Counterclockwise (CCW) I use for Clojure development in Eclipse? I even imported clj-http, clout, compojure, hiccup and ring projects to dive into web development in Clojure. I’m yet to import ClojureScript One, but I guess it’ll take some time before it happens.

I’m also curious how Eclipse EGit will work out as that’s the tool for git.

And the last but not least, you can see the app working on Heroku – http://librarian-clojure.herokuapp.com. Just uploaded v6 (this time on the command line). Have fun!

jacek:~/oss/librarian-clojure
$ git push heroku master
Counting objects: 5, done.
Delta compression using up to 2 threads.
Compressing objects: 100% (3/3), done.
Writing objects: 100% (3/3), 313 bytes, done.
Total 3 (delta 2), reused 0 (delta 0)

-----> Heroku receiving push
-----> Clojure app detected
-----> Using cached Leiningen 1.6.2
       Downloading: rlwrap-0.3.7
       Writing: lein script
-----> Installing dependencies and compiling with Leiningen
       Running: LEIN_NO_DEV=y lein deps
...
-----> Discovering process types
       Procfile declares types -> web
-----> Compiled slug size is 12.5MB
-----> Launching... done, v6
       http://librarian-clojure.herokuapp.com deployed to Heroku

To git@heroku.com:librarian-clojure.git
   1e12914..80c5bfb  master -> master
Languages Leave a comment

Stack traces in Clojure prettier? Almost. It’s Ring

Clojure stack traces got pretty-printed or is it Ring? I believe it’s Ring’s ring.middleware.stacktrace which is described as “Catch exceptions and render web and log stacktraces for debugging.”

I’m developing my first web application in Clojure and I’ve just been pleasantly surprised having seen it (= the nicely-formatted stack trace, but not the stack trace itself). I just followed Interactive Development of Ring and without a handler the following exception was thrown and obviously expected.

jacek:~/oss/librarian-clojure
$ lein ring server
2012-01-28 21:12:09.469:INFO::Logging to STDERR via org.mortbay.log.StdErrLogStarted server on port 3000

2012-01-28 21:12:09.483:INFO::jetty-6.1.25
2012-01-28 21:12:09.526:INFO::Started SocketConnector@0.0.0.0:3000
Exception: java.lang.NullPointerException: null
                     stacktrace.clj:15 ring.middleware.stacktrace/wrap-stacktrace-log[fn]
                     stacktrace.clj:79 ring.middleware.stacktrace/wrap-stacktrace-web[fn]
                         reload.clj:18 ring.middleware.reload/wrap-reload[fn]
                          jetty.clj:16 ring.adapter.jetty/proxy-handler[fn]
                      (Unknown Source) ring.adapter.jetty.proxy$org.mortbay.jetty.handler.AbstractHandler$0.handle
               HandlerWrapper.java:152 org.mortbay.jetty.handler.HandlerWrapper.handle
                       Server.java:326 org.mortbay.jetty.Server.handle
               HttpConnection.java:542 org.mortbay.jetty.HttpConnection.handleRequest
               HttpConnection.java:926 org.mortbay.jetty.HttpConnection$RequestHandler.headerComplete
                   HttpParser.java:549 org.mortbay.jetty.HttpParser.parseNext
                   HttpParser.java:212 org.mortbay.jetty.HttpParser.parseAvailable
               HttpConnection.java:404 org.mortbay.jetty.HttpConnection.handle
              SocketConnector.java:228 org.mortbay.jetty.bio.SocketConnector$Connection.run
             QueuedThreadPool.java:582 org.mortbay.thread.QueuedThreadPool$PoolThread.run

Exception: java.lang.NullPointerException: null
                     stacktrace.clj:15 ring.middleware.stacktrace/wrap-stacktrace-log[fn]
                     stacktrace.clj:79 ring.middleware.stacktrace/wrap-stacktrace-web[fn]
                         reload.clj:18 ring.middleware.reload/wrap-reload[fn]
                          jetty.clj:16 ring.adapter.jetty/proxy-handler[fn]
                      (Unknown Source) ring.adapter.jetty.proxy$org.mortbay.jetty.handler.AbstractHandler$0.handle
               HandlerWrapper.java:152 org.mortbay.jetty.handler.HandlerWrapper.handle
                       Server.java:326 org.mortbay.jetty.Server.handle
               HttpConnection.java:542 org.mortbay.jetty.HttpConnection.handleRequest
               HttpConnection.java:926 org.mortbay.jetty.HttpConnection$RequestHandler.headerComplete
                   HttpParser.java:549 org.mortbay.jetty.HttpParser.parseNext
                   HttpParser.java:212 org.mortbay.jetty.HttpParser.parseAvailable
               HttpConnection.java:404 org.mortbay.jetty.HttpConnection.handle
              SocketConnector.java:228 org.mortbay.jetty.bio.SocketConnector$Connection.run
             QueuedThreadPool.java:582 org.mortbay.thread.QueuedThreadPool$PoolThread.run

The stack trace in the browser was pretty, too.

If stack traces were any indication of what’s ahead, I can’t wait till I taste the other goodies of Clojure, Ring, Compojure, ClojureScript One for web development.

Languages Leave a comment

Leaving aside Java for Clojure

…or shall I say “Leaving aside object-oriented programming (in Java) for functional programming (with Clojure)”?

I seem to be getting into functional programming with Clojure steadily. And I’m serious to have it under my belt. I seem to question all I learnt so far about object-oriented programming with Java and am quite often treading on people’s toes, esp. in the Java community in Poland (where I’m active the most).

I don’t question Java features or syntax, or the way Java programmers see things and moreover use Java for everything they design. I don’t even compare Java to Clojure (I wouldn’t be able to and could cause more damage than anyone could afford to accept). What I’m doing is to be asking questions about the purpose of using Java and its tools and frameworks in a given context – an IDE, design patterns, code-compile-debug-run cycle and such.

I think the main reason is that I began noticing things which I hadn’t been able to before Clojure.

It’s also part of my learning process where I think I should leave aside the emotional baggage to Java I’ve been carrying around with me for years. I must admit I learnt how to design applications with and in Java, and it took me years to grasp all the concepts which ultimately turned me into a seasoned Java specialist (a mixture of a programmer, a application designer and an architect).

I’m way too far from claiming I know how to effectively develop Java applications, but don’t think it would take me months to learn and accustomed to it (unless I’ve already).

I’ve already gone through a couple of books about Clojure (see my take on The Joy of Clojure, Practical Clojure and Programming Clojure and vote for them should they please you) and it turns out the reading list is not going shorter any time soon (see Clojure – Grundlagen, Concurrent Programming, Java, and Clojure in Action and, to be released soonish, Clojure Programming). It turns out that all the people who know Clojure well enough have already written a book about the language or are about to do so. It’s a hectic activity to follow along with their reading. Not an easy task after all, is it?

So, I’ve immersed myself in reading the books and in the meantime am trying to find a place for my new skill – programming functionally with Clojure. And, honestly, it’s not an easy task at all. Not after so many years with Java.

But I’m not giving up. Quite the contrary. I may have found a way out – I’ll be developing simple applications around Web development which I used to cover with various Java frameworks like Apache Wicket, Seam Framework, JavaServer Faces (JSF) or recently Grails and some others.

The idea is to follow the path many Java programmers do when they start developing their object-orientation with Java EE. It’s not only about Java Servlet, but a layer atop, be it the aforementioned JSF or Grails. I’m not going to build a yet another framework for Web development (which I don’t understand so well and don’t have time for), but am going to have a bunch of very simple examples of what I used to cover with Java that should ultimately help me to present the goodies offered by Clojure.

I wish I could also be working with someone interested in learning Scala or JRuby this way. I believe it could help me have another view on a problem with the other language’s solution which would eventually lead me to find the right one in Clojure. Ping me if you’re interested.

Should you have an idea for a very short demo with Clojure, I’d be happy to hear so. Even if it’s already managed by a library/framework in Clojure, I’m up for doing it again on my own hoping I learn Clojure better (when the sources of the solution are available and will be able to have a look at a solution).

I’m thinking aloud and therefore what I wrote may not be useable at all and won’t ever be. You’ve been warned.

Languages 7 Comments

HTML5 and CSS3 seem to have caught my attention

I seem to be getting into the latest developments on browser side where Clojure sits with ClojureScript. During my recent walk with my 3,5-month-old son I was listening to ThinkRelevance: The Podcast – Episode 003 – Brenton Ashworth on ClojureScript One.

For me it was a two-fold experience – firstly, it was a way to learn real English – how it’s used and pronounced, but the most important reason to tune in was to listen to people who designed and developed ClojureScript One to help people get up to speed with, what Brenton and Craig had firstly bothered with, developing highly interactive, JavaScript-rich web pages or how they put it on the website – reducing “the complexity of web development by allowing you to write applications using one language to unify development across the client and the server.” I haven’t tried it out yet, but am into it wholeheartedly (I’m mentally ready to give it a go). I’d like to see how to be in REPL “to make changes to an application in real time”. It must be a breath-taking experience and with my wife and kids away for their holidays I’m not going to wait anymore. Have a go yourself – visit ClojureScript One web site for more up-to-date information. I believe you’ll enjoy it. Drop me an email or comment the blog entry if you fancy watching a screencast about it.

Just along these lines I’ve quite recently been noticing a lot of HTML5 and CSS3 features used in the websites I’m suggested to visit for the reason and it has its effect on my future self-development plans. I seem to be into HTML5/CSS3 and am considering it a new toy I fancy playing with.

My eyes are wide open seeing all the goodies one can build with HTML5/CSS3 with not much time spent. Just a couple keystrokes of sort of declarative programming and a website looks truly overwhelming. They’re so powerful, they nearly blew my mind. I don’t think real Java programmers will face troubles trying it out themselves once they have grasped the basics (since they could understand Java, nothing should be harder :) )

The more HTML5/CSS3 I see, the often I think a browser is no longer a mere runtime for very simple, rudimentary HTML, CSS and JavaScript web pages that attract attention with nice-looking graphics, but it de facto became a sort of application server that’s already on client devices, which is where I used to dispatch my view to (with Java EE and view technologies). I was so scared to enter the realm of client-side development that I was glad to have used object-orientation with Java EE to have done it for me.

Over the years I’ve built understanding where the only viable architecture is composed of a Java EE application server to eventually generate views that are in turn sent over HTTP to rendering device, i.e. a client device (mobile or not) hosting a browser. One monolithic application that’s completely built with Java EE frameworks. HTTP was the way to communicate client runtime with server one.

With AJAX the way clients and servers communicate changed so a page was only partially ready for a complete display and the rest was downloaded at request. I could live with it and it hasn’t changed a lot in the way I thought about enterprise architectures yet introduced a bit of dynamicity in my static object-orientation with Java EE.

With HTML5/CSS3 combo I’m experiencing a twist in my thinking where HTTP is to deliver a complete (client-side) web application that’s hosted directly in a browser – kind of application server – and is supposed to connect the server (the place it was downloaded from) for more data, but it could be that it will never do it and will use different data sources (to ultimately create a mashup). The benefits of having such powerful runtimes – the browsers with HTML5/CSS3 support – right on client devices are enormous.

I used to think that HTML, CSS and JavaScript are for people not able to manage to develop full-blown applications that are supposed to run on a server – a Java EE application server. I was considering HTML/CSS/JavaScript for young people who can only develop PHP applications. With HTML5 and CSS3 I no longer think so. And it makes my mind suffer from a great intellectual pain to grasp all the techniques to deliver highly interactive, feature-rich applications. I do however like it greatly and am sure by the end of the year I’ll have figured out how to use it in my architectures.

Have a look at Spectacular CSS3 Hover Effect Tutorials should you feel a need to experience it yourself.

Languages , , , Leave a comment

Teaching programming language concepts with F#

Remember when I told you about the idea of listening to recordings as taking a walk with my 3-month-old son? Today I watched the other two video recordings about F# (aka fsharp) on the Channel 9 website which I doubt I’d have found spare time otherwise.

I’m slightly interested in F# – it caught my attention just because it’s a functional programming language that borrows a lot from OCaml, SML and few others which I was told Clojure was heavily influenced by, too.

I don’t mean to learn another language – I’ve got a few to learn already with Clojure as the language of the resolutions for 2012 – but since it’s functional and quite modern it’s so akin to Clojure. My take was to completely disregard the differences between Clojure’s and F#’s syntax to solely grasp the general understanding of functional programming underpinnings.

And I do regret no minute spent on the two recordings. Really. There’re a few sentences that made me look at them quite contrary to my first reaction. Some of them are so simple that I still can’t understand why I’m so crazy about them, but it’s not the first time when a sentence made a huge difference in my understanding of topics I couldn’t get my head around before. Just a single sentence said at the right moment and I’m completely overwhelmed by its power. Shall I say enlightened?

They’re not the first and likely the last recordings which I was pointed out as potentially interesting and had almost no Java within. When I glanced at the content they firstly seemed uninteresting yet the weather outside (it’s winter and when freezing there’s not much time to have a walk) made me curious about them. They’re only 40 minutes (the first one) and 20 minutes (the other one) so they’re appropriate for a very short walk.

And so I watched.

And so I took notes when my attention was caught (when it’s white all around and nobody’s out there, it’s so easy to hear your thoughts, calm down and pay attention to details – I’m lovin’ it! :]).

In the first recording prof. Sestoft mentioned at 14:25:

“Fsharp is a functional language where most effects are achieved by computing values not by changing variables.”

That’s when I finally realized that Java (and the state mutating languages) keeps on using classes as a kind of containers you can store your data in (as a state) whereas Clojure, Fsharp and other functional languages operate on values given in a function call. No state available make you think about the data you’ve already got not the one you may collect over time (as state). It reminds me how stateless computations work in Java EE 6 where you only manipulate request data (and now Java object-orientation appears as unnecessary layer with structures that are supposed to hide data – encapsulation – but which rarely do it properly – the many getters that expose internals and hence a need for design patterns to overcome some deficiencies in our understanding of proper object-orientation).

At around 33rd minute I saw the tree which reminded me about graph algorithms to traverse trees – inorder, preorder and postorder tree traversals. Depending on the approach – with preorder tree traversal you’ll get Clojure’s prefix notation while for Java you’d have to use a mixture of preorder and inorder traversals. As I was reminded, Java has options and they used to complicate understanding. In Java, for math operations, like plus (+), minus (-) and such, you use inorder-like, infix notation, but methods change it to prefix notation.

Clojure makes life a bit easier with being consistent for its prefix notation. The first comes a function with arguments afterwards (I don’t want to bring homoiconicity to the table now).

There were quite a few sentences that made me listen more carefully, but I don’t want to spoil it with my attempts above. As an added bonus you’ll learn how pattern matching is achieved in Fsharp and the differences between FP and OOP languages. Worthy recordings.

Languages , 2 Comments

Book review: The Joy of Clojure

I’ve been reading the book “The Joy of Clojure” by Michael Fogus and Chris Houser (Manning, March 2011) for a year or so. I’ve been given a review copy of the book and remember the very first day when I started its reading – I got overwhelmed with its complexity or rather the deep coverage of the “Why” of Clojure. I wasn’t prepared for the book back then.

After a couple of months and some experience with Clojure (rather in theory than practice) I gave it another go. It worked fine this time and so I could publish a review on Amazon.com – The “Why” of Clojure – mind-bending for enlightenment with idiomatic Clojure code.

If you think you need a book about Clojure, think twice before picking up The Joy Of Clojure since “This isn’t intended as a first book on programming, and it may not be an ideal first book on Clojure either” as says the Foreword. There’re quite a few books about Clojure out there and The Joy Of Clojure offers the “Why” only. You can find the other two for the “How” and “Where” in my review.

On to reading Clojure – Grundlagen, Concurrent Programming, Java. It’s gonna be tough as it’s been a while since I was reading German books (it was so long ago that I barely remember it).

Languages 1 Comment

Tune into Expert to Expert: Rich Hickey and Brian Beckman – Inside Clojure

I cannot stress how important it’s to read written and listen to spoken sources of information in order to improve your own skills and gain the advantage of having the best teachers available. As a matter of fact, it doesn’t have to imply technical skills, but any skills.

When you choose your sources well, they may tremendously expand your horizon of technical abilities to get the gist of concepts that otherwise would not be in your reach (well, they would, but might incur a longer time for the learning activity). And most importantly, it’s all for free. Almost inconceivable.

I’ve just come back from a walk with my youngest, 3-week-old son who sleeps while outside, so I’m taking the chance to listen to recordings I can’t find the time to do so otherwise. Today I had a pleasure to listen to Expert to Expert: Rich Hickey and Brian Beckman – Inside Clojure in which Rich explains the concepts of immutability, persistence and concurrency abstractions in Clojure (there’s way more, but to not spoil the presentation, I won’t put all the details here).

It’s not a presentation, and neither is it a discussion (not in the sense of exchanging views with almost a 50/50 time each). Brian took a role of a moderator, and while Rich didn’t seem to need one to feel invited to talk about Clojure’s principles, it helped to tune in.

I highly recommend this recording to anyone wishing tune himself into Clojure, not by reading but listening. Same subject, but different way to reach our brain cells does have its impact. Although I learn no new things whatsoever, I could put them in order. I certainly feel enlightened and encouraged to pursue my Clojure’s endeavour.

Languages Leave a comment

Baby steps in TDD with Clojure and Midje

I’ve got an idea for an app. It’s going to be a GUI app and was wondering how to start off. I’ve lately been impressed by TDD in Java (thanks @krzysztofjelski!) and thought about giving it a go to build the app with Clojure. TDD is language-agnostic, so Clojure should work fine too, shouldn’t it? When I googled “tdd clojure” I came across Midje.

From Midje’s project.clj:

“A TDD library for Clojure that supports top-down (‘mockish’) TDD, encourages readable tests, provides a smooth migration path from clojure.test, balances abstraction and concreteness, and strives for graciousness.”

The official web site of Midje says: “Midje is a test framework for Clojure.”

That seemed the right tool for my needs.

Since I’m using lein, the other google search was for “midje lein” and ended up with Lein midje which turned out not useful for the warm-up of mine into TDD.

Anyway, the project is managed by lein so a small change in project.clj was needed – add [midje "1.3.1"] to :dependencies and you should be able to run lein repl with midje available to (use 'midje.sweet). I was on my way towards TDD happiness in Clojure. Or, again, so thought I.

user=> (use 'midje.sweet)
nil
user=> (fact)
true
user=> (fact (+ 1 1) => 2)
true

That was all I needed to get up and running with TDD. Or so thought I.

When I ran the following code, I realized REPL is about to change the way I consider programming constrained by the change-compile-test development cycle (not to mention red-green-refactor one). I’m now leaning towards thinking about REPL as a kind of a TDD environment and Midje doesn’t seem to help much. It’s a part of REPL already – no, not Midje, but the idea of TDD.

user=> (fact (parse-input "1") => 1)
CompilerException java.lang.RuntimeException: Unable to resolve symbol: parse-input in this context, compiling:(NO_SOURCE_PATH:7)
user=> (defn parse-input [s]
(Integer/parseInt s))
#'user/parse-input
user=> (fact (parse-input "1") => 1)
true

I now tend to believe TDD in Clojure may be a little bit tricky and with almost no prior experience in TDD it may get even tricker. I’ll have to study the matters a little bit further before drawing conclusions, but the short meetup with Midje led me to believe TDD might not be needed while in REPL. It looks like REPL may have taken a little of an area covered by TDD in Java.

Languages 6 Comments

Gentle introduction to Dart with Gilad Bracha

Learning new languages has recently become quite an entertaining mental exercise to me. I’ve never been good at math, and moderately dismissed all the lectures about language designs and principles of lambda calculus or such during my CS studies, and it’s been only recently when I found it very enjoyable.

When my youngest son was born almost 11 weeks ago now, the idea of listening to screencasts and watching videos from miscellaneous conferences and meetings crossed my mind. There’s not much to do when taking a walk with him, after all. He sleeps all the time, and so the same places in an urban forest can easily turn themselves into boring ones.

And it all began a couple of weeks ago. It quickly became a daily habit and with a usual 2-hour walk I can listen to a bunch of recordings. That makes my day and everybody’s happy – my wife, my son, my other kids and me. I couldn’t have thought of a better way to spend time giving so much pleasure to the whole family.

The pile of recordings to watch and listen grows, however I’d greatly appreciate any pointers to other valuable sources you visit.

The recent walks with my baby has even greatly influenced my perception of the Java language itself. Even though it will take time to be able to use the knowledge in practice, if ever, watching how people present it while believing in its value always makes my day.

Along comes Dart.

I’m getting into dynamic and functional languages with Clojure, F#, JRuby (not much, but am going to change it soonish), and more recently Dart. They’re not to solve any practical problems I’m experiencing, but the spirit of their communities caught my attention.

I was a bit skeptical about trying out Dart, but SPLASH 2011: Gilad Bracha – Dart, Newspeak, and More left no choice. Dart seems very promising and Gilad is so sure about it. He speaks about the language for about 30 minutes and what made me want more is Dart’s optional types where a type explicit specification is only for…documentation (!) It’s the external tools to check whether the types are appropriate in a given context. That struck me a lot. My Java heart bled heavily. I’m into it wholeheartedly.

The video I watched today takes a bit longer to digest. Gilad again speaks about Dart, but what was only mentioned in the previous presentation is now quite elaborately explained. Wait no more and tune in to Transcription of A Quick Tour of Dart by Gilad Bracha. You won’t miss a minute watching it. Don’t count on Dart being the language of the future, but listening how Gilad spoke about the features of Dart brought so much knowledge about what I could expect from a language I’d ultimately call mine. It’s Java now, but no one can be sure how long yet.

Languages , 4 Comments

The WAS V8.5 Alpha Liberty Profile November 2011 refresh

The past two weeks I gave two presentations about Java EE 6 and a little bit about Enterprise OSGi with IBM Rational Application Developer V8 and IBM WebSphere Application Server V8. It occupied all my time and I could not continue my self-learning of IBM WebSphere Lombardi Edition V7.2 in any way. I didn’t mind.

When I finally recovered myself from the break, people from the WASdev team released The WAS V8.5 Alpha Liberty Profile November 2011 refresh. When I found out that it comes with OSGi Blueprint support (not to mention Java Servlet 3.0) I couldn’t resist to give it a try.

I’ve been working with Eclipse Indigo SR1 already so all I had to do was to open up the Eclipse Marketplace and search for “Liberty”.

I clicked Install and in a blink of an eye the tooling was available in my local Eclipse IDE. Note the last purple globe icon in the row in the following screenshot.

There’s the WebSphere Liberty Profile Tools feature which provides the tooling.

I believe it comes with two new wizards for OSGi projects – OSGi Application Project and OSGi Bundle Project. I’m not sure, but I don’t think they were available in a vanilla Eclipse Indigo installation.

I meant to give them both a try, but after a couple of failed attempts I eventually gave up. I could deploy a OSGi Application project with a OSGi Bundle Project submodule, but WASdev didn’t respond when I tried to run a servlet off this bundle project. Next time.

I got the tooling and the server installed, though.

I was able to run the server, too.

I’m now ready for further exercises with the Liberty Profile, and am first going to figure out how to run a OSGi Blueprint project within an EBA. Stay tuned.

Frameworks, WebSphere , , Leave a comment