268 Lotus blogs updated hourly. Who will post next? Home | Blogs | Search | About 
 
Latest 7 Posts
Connect 2016 and Darwino 1.0
Mon, Feb 8th 2016 179
Connect 2016 Lead-Up
Tue, Jan 26th 2016 7
That Java Thing, Part 12: Expanding the Plugin - JAX-RS
Thu, Dec 3rd 2015 7
That Java Thing, Part 11: Diagnostics
Tue, Dec 1st 2015 6
That Java Thing, Interlude: Effective Java
Mon, Nov 16th 2015 4
That Java Thing, Part 10: Expanding the Plugin - Serving Resources
Thu, Nov 12th 2015 5
That Java Thing, Part 9: Expanding the Plugin - Jars
Wed, Nov 11th 2015 3
Top 10
Connect 2016 and Darwino 1.0
Mon, Feb 8th 2016 179
How I Maven-ized My Framework
Mon, Dec 8th 2014 8
Delving Into NSF Raw Item Data
Tue, Jul 29th 2014 7
Quick Tip: Wrapping a lotus.domino.Document in a DominoDocument
Tue, Mar 3rd 2015 7
Maven Native Chronicles, Part 2: Setting Up a Windows Jenkins Node
Sun, Jul 26th 2015 7
That Java Thing, Part 12: Expanding the Plugin - JAX-RS
Thu, Dec 3rd 2015 7
Connect 2016 Lead-Up
Tue, Jan 26th 2016 7
SNTT: Reconstructing DateRanges
Thu, Feb 27th 2014 6
So it goes.
Mon, May 12th 2014 6
Working with Rich Text's MIME Structure
Wed, Jul 8th 2015 6


Jesse Gallagher
Blog Title frostillic.us
Blog URL http://frostillic.us
RSS Feed http://unenc.frostillic.us/f.nsf/feed.xml
Validate Feed feedvalidator.org or validator.w3.org
Feed Last Checked Feb 08, 2016 9:45:37 AM EST. Realtime Update:
Location Lansdale, PA, USA


Recent Blog Posts
179
Connect 2016 and Darwino 1.0
Mon, Feb 8th 2016 9:45a   Jesse Gallagher
Last week was Connect 2016 and, while I don't have a full review of it, I felt that it was a pretty successful conference. The new venue was much less weird and more purpose-fitting than expected. Moreover, while the conference content wasn't bursting with announcements and in-depth technical dives like at something like WWDC, it did feel a bit more grounded and less marketing-hollow than the last two. So I'll call it a win. On the OpenNTF front, the conference saw a bit more in the slo
7
Connect 2016 Lead-Up
Tue, Jan 26th 2016 9:02a   Jesse Gallagher
Phew, well, my plugin series continues its hiatus due to how thoroughly swamped I've been with work the last couple months. It will return in time, ready to dive into the fruitful and terrifying topic of Maven-ization. In the mean time, we're very close indeed now to this year's Connect, and I'm looking forward to it. There are a number of sessions that I'm rather looking forward to, but I'd like to mention two due to my indirect and direct association with them, respectively. Firs
7
That Java Thing, Part 12: Expanding the Plugin - JAX-RS
Thu, Dec 3rd 2015 3:21p   Jesse Gallagher
A couple of months back, Toby Samples wrote a series on using Wink in Domino. I'm not going to cover all of that ground here, but it's still worth dipping into the topic a bink, as writing REST services in an OSGi plugin is a great way to not only add capabilities to your XPages apps, but to also start making your data (and programming skills) more accessible from other platforms. There are two main terms to know here: "JAX-RS" and "Wink". JAX-RS stands for "Java API for RESTful Web
6
That Java Thing, Part 11: Diagnostics
Tue, Dec 1st 2015 8:43a   Jesse Gallagher
Though my surprisingly-packed schedule the last few weeks caused a hiatus, it's time to retun to this series with a quick description of some of the diagnostic tools available to you when doing plugin development (outside of connecting the debugger, which I may do eventually). The primary tool in your "what the heck is going on?" toolbox should be the XPages Log File Reader. This app does a wonderful job providing a web UI for the important diagnostic files you'll likely need to see du
4
That Java Thing, Interlude: Effective Java
Mon, Nov 16th 2015 8:15a   Jesse Gallagher
While taking a short breather in my continuing Java series, I think that now is a good time to reiterate my advice for all Domino developers to read Effective Java. It's probably not the best way to learn Java from scratch, but it's an invaluable tour through tons of important Java concepts. Even if you don't use most of the knowledge immediately, reading every section will help immerse you in the language and give you a better appreciation for its texture, which is one of the most im
5
That Java Thing, Part 10: Expanding the Plugin - Serving Resources
Thu, Nov 12th 2015 12:02p   Jesse Gallagher
After sharing code, one of the handiest uses of a plugin is sharing web resources - stylesheets, JavaScript files, and so forth. This process is similar to the last couple steps in that, though it is not very complicated on the whole, it's pretty non-obvious how to get around to doing it. To start with, we'll create some resources to serve up. Expand the src/main/resources folder in your project (it will be slightly more useful to use the "normal" folder version and not the source fold
3
That Java Thing, Part 9: Expanding the Plugin - Jars
Wed, Nov 11th 2015 11:50a   Jesse Gallagher
So it appears that I once again forgot to commit my changes. Well, consider this a cautionary tale, but we can still salvage the situation a bit by committing the previous changes before embarking on an unrelated modification - it's that mixing of different changes that can cause trouble in a source control repository. [IMAGE] For today's post, we'll add a third-party Jar to our plugin in order to use it internally and provide it to external applications (and we'll cover why those ar
4
That Java Thing, Part 8: Source Bundles
Tue, Nov 10th 2015 7:46a   Jesse Gallagher
Before anything else today, Eric McCormick reminding that yesterday's post missed the final step: committing the changes. So, let's take care of that right now. On my side, since my Windows VM is also being accessed from the Mac side, it's worthwhile to add a .gitignore file to the root of the repo to keep out all the .DS_Store nonsense. GitHub's Java gitignore is a good start, though skipping the part about ignoring Jar files. In your text editor of choice, create a new file named ".
4
That Java Thing, Part 7: Adding a Managed Bean to the Plugin
Mon, Nov 9th 2015 6:37a   Jesse Gallagher
For today's step, we'll deal more with the meat of the task: putting your own code in the plugin. There are a lot of options for what a plugin can provide, ranging from just storing classes to be accessed from elsewhere to being full-on OSGi web applications. Adding a managed bean certainly falls on the simpler side of this spectrum, but it's also one of the most common uses. These steps should also be very familiar if you've created a managed bean in an XPages NSF before. Before we g
5
That Java Thing, Part 6: Creating the Feature and Update Site
Sun, Nov 8th 2015 10:45a   Jesse Gallagher
The last post covered turning our nascent plugin into a proper XPages library, so now it's time to fill in the remaining pieces to get it installed. To do that, we'll need a feature and an update site. The feature will point to our plugin - in a more-complicated setup, this could point to several related plugins, but we'll just need the one. The update site will do similarly, referencing the feature in a way that Eclipse-type platforms know about. Go to File → New and choose "Feature
1
That Java Thing, Part 4: Expanding the Plugin
Fri, Nov 6th 2015 8:48a   Jesse Gallagher
In the last post, we created an empty plugin project for our XPages library. Today, we'll flesh that plugin out a bit and add the actual XSP hooks. The first step is to start filling in some details in the plugin's Manifest file, which is the core description of what the plugin does and what it requires in its environment. To begin with, open the MANIFEST.MF file in the META-INF folder of your project and check the "This plug-in is a singleton" checkbox: [IMAGE] During one of the ste
1
That Java Thing, Part 4: Creating the Plugin
Thu, Nov 5th 2015 9:38a   Jesse Gallagher
To make a basic XPages library, we'll need to create the trio of OSGi projects: the plugin, the feature, and the update site. For a long time, the XSP Starter Kit has been a great go-to starting point for this sort of thing. It definitely covers almost all of the potential ground, but it can be a bit overkill when you just want to put some classes in a shared place. So, for this exercise, we'll start from scratch. But before we do that, we should create a Git first. This isn't required,
3
That Java Thing, Part 3: Eclipse Prep
Wed, Nov 4th 2015 4:26a   Jesse Gallagher
Before you dive into OSGi development, you'll need a proper development environment, and that usually means Eclipse. Domino Designer, being Eclipse-based, can technically do the job and has the advantage of some of the setup being done, but it's so out-of-date at this point that it's not worth it (believe me, I tried originally). Newer Eclipse versions have improved noticeably, so it's best to grab a recent version. Currently, that means Mars, or Eclipse 4.5.1. Before Eclipse, you'll
1
That Java Thing, Part 2: Intro to OSGi
Tue, Nov 3rd 2015 6:44a   Jesse Gallagher
OSGi once stood for "Open Services Gateway initiative", but that name slid from "impossibly vague" to "entirely obsolete" rather quickly. For our needs, OSGi is a mechanism for bringing sanity to the "big pile of Jars" that you might otherwise have in a large Java system. It provides a standardized way to describe the name of a library, its version, its dependencies, its capabilities, and its interactions with other libraries. In this way, rather than just "commons-io-2.1.jar", y
1
That Java Thing, Part 1: The Java Problem in the Community
Mon, Nov 2nd 2015 1:20p   Jesse Gallagher
Java has been a bugbear for the Domino community for a long time. Though Notes and Domino have presented a top-to-bottom (mostly) Java environment for years, the monumental inertia of the corporate development community, the platform's tortured history of insufficiently-fleshed-out Java hooks, and IBM's "pay no attention to that man behind the curtain" pitch with regard to the language created an environment where Java is often something for "other developers". XPages represented a t
2
Domino's Server-Side User Security
Sun, Nov 1st 2015 7:41a   Jesse Gallagher
The other day, Jesper Kiaer write an interesting two-part sert of blog posts talking about the security implications of HTTPEnableConnectorHeaders, something I mention in my setup example. In it, he describes the ability to specify an arbitrary username as a security hole, which I don't agree with, but I see where he's coming from. It certainly has, shall we say, implications. The $WSRU header comes along for the ride when you enable the HTTPEnableConnectorHeaders notes.ini property (off
1
Satisfying Designer's Peculiar OSGi Constraints in Tycho
Mon, Oct 12th 2015 4:33p   Jesse Gallagher
Before anything else, I should mention that this post is entirely on the topic of building OSGi plugins with Maven. If you're not doing that yet, this probably won't be particularly useful. For the most part, when building OSGi plugins for XPages, you can be fairly confident that the available plugins will be fairly similar between Notes and Domino. That's not quite always the case, though - there are a set of plugins that are available in Domino that aren't present in Designer's runt
2
Release Day
Sat, Oct 3rd 2015 6:34p   Jesse Gallagher
Today, I put two long-overdue releases up on OpenNTF. First and by-far-foremost is version 2.0.0 of the OpenNTF Domino API. The major version reflects not so much a major new architectural change over the 1.5.x release candidates as it does the fact that those releases were conservatively named and presaged a Java-style "1.x forever" future. Various development builds and release candidates have been used in production by the API team and others for a while now, and so this represents a
5
The Podcasts I Listen To
Tue, Sep 22nd 2015 12:46p   Jesse Gallagher
Over the years, I've accumulated a stable of podcasts I listen to, mostly tech-related (and then mostly Apple-related), and I realized that this may be a handy list for anyone looking to pick up some new listening material. I've uploaded the full list here, but here are some of the highlights: Accidental Tech Podcast - This show is hosted by John Siracusa (of OS X review fame), Marco Arment (of Overcast and Peace fame), and Casey Liss (of, now, ATP fame). It's almost all about technolog
3
Seriously, Though: Reverse Proxies
Wed, Sep 16th 2015 4:28p   Jesse Gallagher
So, Domino administrators: what are your feelings about SSL lately? Do they include, perhaps, stress? It's "oh crap, my servers are broken" season again, and this time the culprit is a change in Apple's operating systems. Fortunately, in this case, the problem isn't as severe as an outright security vulnerability like POODLE and, better still, there is a definitive statement from IBM indicating that they are going to bring their security stack up to snuff almost in time. But this isn
1
XPages Devs: Enable "Refresh entire application when design changes"
Mon, Sep 14th 2015 11:48a   Jesse Gallagher
When developing an XPages application of beyond-minimal complexity, you're likely to run into a problem where your app starts saying that a class is incompatible with itself in one way or another. The exception usually traces down to something like "foo.SomeClass is incompatible with foo.SomeClass" or "cannot assign instance of foo.SomeClass to field X..." where the field is that same class. This has cropped up since time immemorial. It's actually, though, something that IBM sort-o
1
Dealing with OSGi Fragments in Tycho and Designer
Fri, Sep 11th 2015 6:30p   Jesse Gallagher
This post is partly to spread information publicly and partly a useful note to my future self for the next time I run into this trouble. In OGSi, the primary type of entity you're dealing with is a "Bundle" or "Plug-in" (the two terms are effectively the same for our needs). However, there's a sort of specialized type that you may run into called a "Fragment". They're similar to a plug-in in that they're a contained unit of Java code and resources, but they have the special prope
0
My MWLUG 2015 Presentation, "Maven: An Exhortation and Apology"
Sun, Aug 30th 2015 6:07p   Jesse Gallagher
At prophesied, I gave a presentation on MWLUG last week. Keeping with my tradition, the slides from the deck are not particularly useful on their own, so I'm not going to post them as such. However, Dave Navarre once again did the yeoman's work of recording my session, so it and a number of other sessions from the conference are available on YouTube. In addition, my plan is to expand, as I did earlier today, on the core components of my session in blog form, in a way that wouldn
1
Wrangling Tycho and Target Platforms
Sun, Aug 30th 2015 4:16p   Jesse Gallagher
One of the persistent problems when dealing with OSGi projects with Maven is the interaction between Maven, Tycho, and Eclipse. The core trouble comes in with the differing ways that Maven and OSGi handle dependencies. Dependency Mechanisms The Maven way of establishing dependencies is to list them in your Maven project's POM file. A standard one will look something like this: com.google.guava guava 18.0 This tells Maven that your project depends on Guava version 18.0. The "
2
MWLUG 2015 - Maven: An Exhortation and Apology
Sun, Aug 16th 2015 11:55a   Jesse Gallagher
At MWLUG this coming week, I'll be giving a presentation on Maven. Specifically, I plan to cover: What Maven is Why Domino developers should know about it Why it's so painful and awkward for Domino developers Why it's still worth using in spite of all the suffering How this will help when working on projects outside of traditional Domino The session is slated for 3:30 PM on Thursday. I expect it to be cathartic for me and useful for the attendees, so I hope you can make it.
1
Maven Native Chronicles, Part 3: Improving Native Artifact Handling
Sun, Jul 26th 2015 8:38p   Jesse Gallagher
This post isn't so much a part of the current series as it is a followup to a post from the other week, but I can conceptually retcon that one in as a prologue. This will also be a good quick tip for dealing with Maven projects. In my previous post, I described how I copied the built native shared library from the C++ project into the OSGi fragments for distribution, and I left it with the really hacky approach of copying the file using a project-relative path that reached up into the oth
7
Maven Native Chronicles, Part 2: Setting Up a Windows Jenkins Node
Sun, Jul 26th 2015 10:16a   Jesse Gallagher
Before I get to the meat of this post, I want to point out that Ulrich Krause wrote a post on a similar topic today and you should read it. The build process I've been working with involves a Jenkins server running on OS X (in order to build iOS binaries), and so it will be useful to have a Windows instance set up as well to run native builds and, importantly, tests. Jenkins comes with support for distributed builds and makes it relatively straightforward. To start with, I installed Virt
4
Maven Native Chronicles, Part 1: Figuring Out nar-maven-plugin
Fri, Jul 24th 2015 2:48p   Jesse Gallagher
As I mentioned the other day, my work lately involves a native shared library that is then included in an OSGi plugin. To get it working during a Maven compile, I just farmed out the actual build process to Visual Studio's command-line project builder. That works as far as it goes, but it's not particularly Maven-y and, more importantly, it's Windows-only. In looking around, it seems like the most popular method of doing native compilation in Maven, especially with JNI components, is ma
6
Adding Components to an XPage Programmatically
Sun, Jul 19th 2015 8:16a   Jesse Gallagher
One of my favorite aspects of working with apps using my framework is the component binding capability. This lets me just write the main structure of the page and let the controller do the grunt work of creating fields with validators and converters. There's a lot of magic behind the scenes to make it happen, but the core concept of dynamic component creation is relatively straightforward. An XPage is a tree of components, and those components are all Java objects on the back end, which
5
Quick-and-Dirty Inclusion of a Visual C++ Project in a Maven Build
Sat, Jul 11th 2015 6:26p   Jesse Gallagher
One of my projects lately makes use of a JNI library distributed via an OSGi plugin. The OSGi side of the project uses the typical Maven+Tycho combination for its building, but the native library was developed using Visual C++. This is workable enough, but ideally I'd like to have the whole thing part of one smooth build: compile the native library, then subsequently copy its resultant shared 32- and 64-bit libraries into the OSGi plugins. From what I've gathered, the "proper" way to d
6
Working with Rich Text's MIME Structure
Wed, Jul 8th 2015 7:28p   Jesse Gallagher
My work lately has involved, among other things, processing and creating MIME entities in the format used by Notes for storage as rich text. This structure isn't particularly complicated, but there are some interesting aspects to it that are worth explaining for posterity. Which is to say, myself when I need to do this again. As a quick primer, MIME is a format originally designed for email which has proven generally useful, including for HTTP and, for our needs, internal storage in NSF.
4
Quick Tip: Override Form-XPage Mapping in xsp.properties
Thu, Jun 11th 2015 1:17p   Jesse Gallagher
This is sort of an esoteric feature, but I just ran across it and it fits nicely into an XPages bag of tricks. Specifically, as it turns out, there's a way to override the default "which XPage should be used for this document?" behavior in some cases. The most-commonly-known behavior is the "Display XPage Instead" set on the form (or the default form if-and-only-if the document has an empty Form field). This wins in all cases, and is the only way to get an XPage to open for a document
0
Parsing JSON in XPages Applications
Thu, May 21st 2015 11:47a   Jesse Gallagher
David Leedy pointed out to me that a post I made last year about generating JSON in XPages left out a crucial bit of followup: reading that JSON back in. This topic is a bit simpler to start with, since there's really just one entrypoint: com.ibm.commons.util.io.json.JsonParser.fromJson(...). There are a few variants of this method to provide either a callback to call during parsing or a List to fill with the result, but most of the time you're going to use the variants that take a Strin
4
Quick PSA: LS2J Problems in 9.0.1 FP3
Tue, May 19th 2015 1:25p   Jesse Gallagher
While I'm at it, I realized that it may be useful to further spread information about the problem that led to me fiddling with the latest IFs and JVM patches in the first place: the LS2J problems in 9.0.1 FP3. Specifically, it's borked. The main way most people have encountered this is via an exception dialog when attempting to add new plugins to an Update Site NSF, since that uses LS2J to accomplish its task - it displays several layers of stack and the upshot is that there's a j
2
Quick Tip: Re-Enabling Disabled Designer Plugins
Tue, May 19th 2015 12:58p   Jesse Gallagher
Recently, I had a case where my installed Designer plugins stopped appearing, immediately made obvious by the libraries disappearing from XPages applications and Designer listing hundreds of class-not-found errors. At first, I figured that the local plugins had been deleted, but trying to install from update sites curtly informed me that they contained nothing new for me. It turned out that my local plugins had been somehow marked disabled by Designer. The fix for this was to go to File
1
How I Use JAX-RS in the frostillic.us Framework
Fri, May 1st 2015 5:59p   Jesse Gallagher
Inspired by Toby Samples's new blog series on JAX-RS in Domino, I'd like to share a description of how I made use of it to write the REST services in the frostillic.us Framework. This is not intended to be a from-scratch introduction - Toby is handling that well so far - but instead assumes a certain amount of knowledge with OSGi development and why you would want to do this in the first place. The goal of my REST services is to provide an automatic REST/JSON API for any Framework model
2
Musing About Multi-App Structure
Tue, Apr 28th 2015 11:25a   Jesse Gallagher
One of the projects I'm working on is going to involve laying the foundations for a suite of related XPages applications, and so I've been musing about the best way to accomplish that. I'll also want to do something similar down the line for OpenNTF, so this is a useful track for consideration. Traditionally, Notes and XPages applications are fairly siloed: though they share authentication information and some configuration via groups, integration between them is fairly ad-hoc. I'm no
3
Building on ODA's Maven-ization
Tue, Mar 31st 2015 7:30p   Jesse Gallagher
Over the weekend, I took a bit of time to apply some of my hard-won recent Maven knowledge to a project I wish I had more time to work with lately: the ODA. The development branches have been Maven-ized for half a year or so, but primarily just to the point of getting the compile to work. Now that I know more about it, I was able to go in and make great strides towards several important goals. As a preliminary note: don't take my current implementations as gospel. There are parts that wi
3
Auto-OSGi-ifying Maven Projects
Sat, Mar 28th 2015 3:15p   Jesse Gallagher
In my last post, I discussed some of the problems that you run into when dealing with Maven projects that should also be OSGi plugins, particularly when you're mixing OSGi and non-OSGi projects in the same Maven build (in short: don't do that). Since then, things have smoothed out, particularly when I split the OSGi portion out into another Maven build, allowing it to consume the "core" artifacts cleanly, without the timing issue described previously. But I ran into another layer of th
2
Tycho and Tribulations
Sat, Mar 14th 2015 2:02p   Jesse Gallagher
For the last few weeks, a large part of my work has involved dealing with Maven, and much of that also involves Eclipse. It's been quite the learning experience - very frustrating much of the time, but valuable overall. In particular, any time OSGi comes into play, things get very complicated and arcane, in non-obvious ways. Fair warning: this blog post will likely start out as an even-keeled description of the task at hand and descending into just ranting about Maven. The Actors To sta
7
Quick Tip: Wrapping a lotus.domino.Document in a DominoDocument
Tue, Mar 3rd 2015 3:13p   Jesse Gallagher
In the XPages environment, there are two kinds of documents: the standard Document class you get from normal Domino API operations and DominoDocument (styled NotesXspDocument in SSJS). Many times, these can be treated roughly equivalently: DominoDocument has some (but not all) of the same methods that you're used to from Document, such as getItemValueString and replaceItemValue, and you can always get the inner Document object with getDocument(boolean applyChanges). What's less common,




Created and Maintained by Yancy Lent - About - Planet Lotus Blog - Advertising - Mobile Edition