Subscribe: Tales from the Evil Empire
Added By: Feedage Forager Feedage Grade B rated
Language: English
application  cache  code  community  core  harvest  make  module  mvc  new  orchard core  orchard harvest  orchard  output  site 
Rate this Feed
Rate this feedRate this feedRate this feedRate this feedRate this feed
Rate this feed 1 starRate this feed 2 starRate this feed 3 starRate this feed 4 starRate this feed 5 star

Comments (0)

Feed Details and Statistics Feed Statistics
Preview: Tales from the Evil Empire

Tales from the Evil Empire

Bertrand Le Roy's blog


Orchard Harvest 2017–Orchard Core CMS

Wed, 22 Feb 2017 21:57:12 GMT

For the last presentation of the day, Sébastien explained what Orchard Core is all about. Orchard Core runs on ASP.NET Core, and as a consequence is leaner, faster, and cross-platform. One big change is that its content is persisted as documents instead of relational tables.

Other differences include:

  • The admin theme is now a setting.
  • The content item editor has a new live preview feature, content editor, an flow part that largely replaces the layout feature of Orchard 1. The whole thing is responsive and easy to work with.
  • A navigation is one single content item, with its hierarchy persisted as a single document. This is very fast, but preserves the extensibility of Orchard 1: menu items are still themselves content items, it’s just that they are persisted all together in the containing menu content item’s document. This also helps versioning the menu as a whole, as well as efficiently caching it.
  • The order of parts in type definitions is easier to change.
  • There are named parts.
  • Blogs are just lists of blog posts.
  • Tokens are input into Handlebar templates (for example in Autoroute).
  • The widget editor supports drag and drop between zones, and has an undo button.
  • Widgets can be used in “flow pages”, in which case their editor is displayed inline in the content item editor.
  • Recipes can have dynamic values and define variables. They are also JSON documents.
  • It’s crazy fast. 15ms to render a blog with widgets without caching on a laptop in Debug mode under load (2000 rps). This is way faster than Orchard 1 with caching on.
  • Creating and setting up a new tenant is instantaneous. So is enabling a module.
  • Memory usage: tenants are lazily loaded on their first requests, and 500 tenants fit in 2GB on a 64 bit machine.

Migrating data will not be trivial, and will have to go through import/export. Migrating modules should be easy. Modules are like a mini-MVC application, much like in Orchard 1.

You can follow the progress on

It’s also a great time to start contributing!

Orchard Harvest 2017–YesSql

Wed, 22 Feb 2017 19:01:00 GMT

Sébastien Ros gave a surprise demo of YesSql, the document database interface over relational databases that powers Orchard Core’s data access. YesSql stores plain objects into documents stored on a relational database. It supports SQL Server, MySql, Postgre, Sqlite, LightningDB, and in-memory. YesSql also allows for querying those objects using queryable indexes. Those indexes are projections of documents into structured tables, that only exist for the purpose of being queried.

YesSql supports map indexes that map one document to one or more index records, and map-reduce indexes that aggregate documents. For all operations, you create a transactional session from a store object. The store object needs to be initialized once before the database can be used for YesSql. The session can save documents using the Save method, which results in a JSON-serialized record in the database. Known classes, as well as anonymous objects can be persisted.

When fetching documents, it’s possible to get a dynamic object when the type is not known. If you know the type, you can GetAsync(id).

An index is built by deriving from IndexProvider. The Describe method defines the mapping from the type T to another type that derives from MapIndex, and has properties that will get serialized as individual columns of the index table in the database. That table can then be queried in rich manners by calling QueryAsync(), that can then be chained with Where, OrderBy, and other Linq extensions.

When building an index, it’s possible to pre-filter documents, which means that there is no runtime cost to filtering when the conditions are known in advance.

It’s also possible to perform joined queries between several indexes.

Map/reduce indexes can first do a Map, then usually a Group, and finally compute some aggregate values over the group in Reduce. There is an optional Delete method that describes how to update an index in case of document deletion, to avoid having to re-compute the whole index.

All indexes are automatically maintained.

During questions, Sébastien explained how integer document ids are acquired: the sessions get assigned next ids one by one, and different sessions will be assigned new ids that are guaranteed to be owned by them. The result is not necessarily sequential, but enables clients to know unique ids on creation without round-tripping to the database.

Orchard Harvest 2017–Client-side components in Orchard

Wed, 22 Feb 2017 17:32:32 GMT

A client-side component is defined as a component that implements its rendering and behavior on the client, with server interactions going through some APIs.

Such components can be implemented in Orchard using a range of technologies from simple shape templates to full-blown parts and elements. A good compromise is layout snippets. Layout snippets can be implemented with a simple SomethingSnippet.cshtml file that can simply be dropped into the Views folder of a module, and is then available as a regular element in layouts. Snippets can also be associated with a manifest that specifies metadata such as toolbox icons, and also configurable fields.

Daniel showed how to use a shape table provider in his module to add an API URL onto his shape from site settings.

To manage client-side assets, he’s using Gulp. There’s a choice however to put the generated assets in source control or not. His preference is to keep them out: they don’t get stale, don’t need to be pushed on all modifications, it reduces noise and footprint. The downside is of course that developers wanting to modify the module need to install the tooling.

The component client assets are Handlebars templates, TypeScript, and scss, and they are bundled using Browserify. The corresponding tooling is brought in by a package.json file.

Things get a little more complicated when building Angular components, because of Angular routing, which happens purely on the client and integrates into browser navigation. That requires integration with Orchard server-side routing, which doesn’t work out of the box. The way to make it work is to use the routing features from the IDeliverable.Bits module to add a base URL tag to the page and tweak routing so Orchard can recognize that base URL as an Orchard route. The rest of the URL will be handled client-side by the Angular component to display the proper thing.

One last thing that is required is to prepare some data for the scripts to use, such as base paths. This is done by rendering those pieces of data into data-* attributes in the markup.

Orchard Harvest 2017–Localization

Wed, 22 Feb 2017 16:29:49 GMT

Benedek is one of the founders of Lombiq, and the caretaker of Orchard localization. Application localization requires taking into account cultural differences such as gender, formal vs informal, pluralization, right to left, verbosity, accents, etc. In Orchard, all localizable strings should be wrapped in T() calls. That is enough to make the string localizable in PO files. Some strings can contain placeholders, such as T("Hello, I’m from {0}."). You can use the Vandelay Industries module’s translation extraction feature to extract all the T strings from a module into po files. The module produces a zip archive that contains the layout of localization files that you’d unzip into the site in order to install it. To localize, you can copy any po file from its en-us directory to a new directory for the new culture, then translate the strings inside.

Manual translation of po files is not the only option, however. The Orchard community is crowd-sourcing and centralizing translation of the core platform and of the most common modules on Crowdin. Benedek uploads po files for all new releases of Orchard onto the site, then anybody can contribute translations, with machine translation suggestions from Crowdin, and proofread existing translations. The resulting translated strings can be downloaded as an archive that can be unzipped over the web site. You can then add cultures in Orchard settings, switch the default culture and start using the new translations.

Now that we know how to localize static strings defined in modules, we can look at how to translate contents. Translating contents can be challenging, especially in cases where relationships between items exist, such as taxonomies, or media library picker fields. All the tools are in place in Orchard for this to work however, with the possibility to specify items as culture neutral, cloning capabilities, and culture matching of associated items. Navigation is still work in progress but is following the same path.

A guide to localization is available from

In questions, bulk translation was mentioned, for which the q42 module is very useful.

Jorge also mentioned how the en-us translation can be used to hack the site into displaying a different string in English than what’s specified in code.

Orchard Harvest 2017–Writing a theme for Orchard Core

Wed, 22 Feb 2017 15:02:46 GMT

In the first session of the second day of Orchard Harvest, Steve Taylor showed how to build a new theme for Orchard Core. All the pieces are already in place for building themed sites, and the work is similar to Orchard 1.x themes, except for some json file editing because of missing admin UI in places. New Razor Pages features can be used, such as tag helpers, @inject directives, etc. The tag helpers in particular, coupled with Orchard’s shapes, make for very clean markup in view files. The video for the talk, when available, will be a valuable reference for people who want to get started building sites with Orchard Core: the CMS now looks feature-complete enough to do some serious work. Widgets are there, the shape system is there, search, navigation, all work. That Steve was able to build a complete site and theme under an hour (with some pre-built css and views, of course) shows how far Orchard Core has gone already.

Orchard Harvest 2017–What is Orchard Core SaaS Framework?

Tue, 21 Feb 2017 21:52:01 GMT

Nick Mayne is one of the main developers working on Orchard 2.0, a.k.a. Orchard Core.

Orchard Core started as an MVC application, but this had several challenges with multi-tenancy and Glimpse integration. To solve those problems, Nick moved things around so MVC actually is a module instead. I found that really interesting as I had implemented something really similar when I built DecentCMS: Express is loaded as a module, for each tenant.

In his first demo, he started with a simple ASP.NET Core application, and transformed it into an Orchard Core application where the application code lives in a module instead of the startup class where it began. In the module, a simple class derives from StartupBase and overrides Configure and ConfigureServices.

The second demo is improving on the first one by adding actual MVC to the application. The existing module is modified to register MVC. Nick then added a new module, gave it a controller with an Index action. The result is MVC in an Orchard Core site with a module registering MVC, and another using MVC. In a full Orchard stack, the module registering MVC would be “the MVC module”, and the other would just take a dependency on it.

Next, Nick showed how to point the site’s host to an alternate module location. This is how themes are added: services.AddExtensionLocation(“Themes”). You can also modify manifest definitions.

For the moment, we haven’t created any tenants. In other words, everything has been running on the default tenant. Using services.AddSitesfolder(“App_data”, “Sites”), it’s possible to point the application to locations where tenants are defined. Nick created two sites with their own manifests, which creates two tenants with all features enabled. To differentiate them, he injected the ShellSettings into the controller, whose action can now output properties coming from each tenant manifest.

Finally, Nick showed how to swap MVC for Nancy. Yes, one interesting consequence of having MVC as a module is that you may not use it at all, and you may even use something else altogether, such as Nancy. Moreover, you may even have one module built on Nancy, and another on MVC, all running in the same host. This is really very cool and shows just how low footprint Orchard Core is, and how its services, such as multi-tenancy and modules, come at a very low price and impose very few constraints on the whole system. In other words, you get exactly what you want, and nothing more.

Orchard Harvest 2017–Scaling Orchard

Tue, 21 Feb 2017 20:35:47 GMT

Rob King works for Bede Gaming, which specializes in providing a platform for gambling web sites. The company moved to Orchard in 2013, and has strong scalability requirements, with sites serving millions of requests per day.

One of the problems they are facing is dependency management. One of the ways they deal with that problem is that they avoid features depending on each other, but instead try to have dependencies on abstractions. Instead of having feature A depending on feature B because they have common interfaces, those interfaces are extracted into a common module, and both features are made to depend on it.

They cache layer rules to avoid going to the content manager to get get them.

The Bede web sites are typically entirely dealing with authenticated users, so caching has to implement donut caching techniques. They also use Redis for distributed output caching, plus in-memory caching.

They had an incident when they had a deadlock on scheduled tasks that caused the scheduled tasks table to fill up with millions of records. It was solved with a node-aware version of the scheduled task manager.

Being multi-node aware everywhere was key to fixing many of the problems faced.

Orchard Harvest 2017–What’s new in ASP.NET MVC Core 2.0

Tue, 21 Feb 2017 19:43:55 GMT

Taylor Mullen from the ASP.NET team is a developer working on MVC Core 2.0. In this session, he went over the design of the new Razor Pages feature. He carefully explained what is difficult with MVC currently, in order to justify the feature. He actually started by showing what it’s not: it’s not PHP-like, and it’s not a new take on previous “ASP.NET Pages” features.

Razor Pages enable you to get started rendering views without having to build a controller. As the page is growing more complex, the code can be moved into a “page model”, that is starting to look more like a controller, mixed with a view model, but that is actually closer in spirit to what you’d have in a MVVM pattern. This all creates a smoother “grow up” story.

The last piece in the puzzle is routing, which is dealt with using a nice model binding syntax on the @page directive: “@page foo/{id:int}” would setup the route so “foo/12” would hit the page with the id int parameter set to the value 12.

Taylor then showed how al this is wired up together, and how the same plumbing could be used with your own custom providers, in particular for directives.

Orchard Harvest 2017: when output cache just isn’t enough

Tue, 21 Feb 2017 16:49:02 GMT

Daniel Stolt and Chris Payne from IDeliverable presented some new output caching techniques that they’ve developed. The problem that they’re solving is what happens when you have to output user-specific data into rendered contents. In those cases, you want to cache the constant parts of the output, while keeping holes dynamic. This is known as donut caching.


The holes in the donuts can be puched into rich text using a placeholder with the %%{name} notation. Those placeholders are not exactly tokens, but behave similarly, and are also extensible.

They also have an item-level cache part that can be added for instance to widgets, and used to set the output cache policy for that specific item, or to exclude it from the cache altogether. The item-level cache configuration is very rich, and allows for very fine-grained control. This can even be extended with your own “vary by” providers.

Cached output is stored into the same place as Orchard’s built-in output cache. This means that any provider that already exists can be used without changes.

The module also introduces some new options to evict pages that use a given widget, that gives a lot more control than the built-in feature. For instance, if you have a menu widget on all your pages, you don’t want just any change on the menu to cause the eviction of every single page in the site from output cache.

It’s possible to cache summary versions of items, such as the ones in search results. In this case, individual items in a results list, if they are in the cache, do not need to be re-rendered, but can come from the cache. This is quite neat as the caching structure of the page in this case is nested.

Finally, it is possible to trigger pre-rendering of an item into the output cache whenever it gets evicted (on a change, typically).

IDeliverable’s donut caching module is a premium module that can be tried for free on localhost, bought, or subscribed to.

Orchard Harvest 2017 – Using external data with Orchard

Tue, 21 Feb 2017 16:08:39 GMT

Jorge Agraz is opening the conference after Sébastien Ros’ keynote with a talk about using external data in Orchard. Jorge work for Onestop, a company that builds e-commerce sites. Their web sites get their commerce data from APIs and then used to display that through their controllers with Orchard shapes. They attempted to use widgets instead of controllers, but that came with some significant maintenance problems.


With the latest version, commerce pages are actual Orchard content types: category, product and shopping cart. They have elements, fields, and parts to represent everything. A Product driver lazily gets data from the commerce API and instantiates more than 20 shapes from it, that can be used to display the contents. This provides a lot of flexibility, and is easier to move around between dev, staging, and production servers. The number of shape alternates in typical themes has been drastically reduced from 50 to 90 down to 6.

Interestingly, themes have a shape table provider that can be used to turn shapes on or off, and configure them, going beyond what can do.

Unimportant egocentric rant: don’t .ToUpper() your titles

Sat, 09 Apr 2016 16:23:00 GMT

Here’s a minor inconvenience that I’m going to put out there in the hope that one or two of the horrible people responsible for it may realize the errors of their ways and make the world a marginally better place.

So you like your titles to be all caps. Fine. I’m not sure why you insist on screaming like that, but that’s your choice, and it’s your web site/blog. If you are going to do this, however, please don’t do this:


And not just because you neglected to specify a culture (you monster). No, this is wrong because next time the guy who builds the week in .NET wants to mention your site and copies the title over, he’s going to copy this:


instead of this:

How to use Entity Framework to make a rainbow

He’s going to curse loudly, his kids may hear him, and they’ll grow up to become as obnoxious as he is, all because of you. Well done.

This is particularly infuriating because there is a perfectly good way to do this bad thing that you insist on doing. In your CSS, just do something like this:

h1 { text-transform: uppercase; }

There. Was that so hard?

Except that no. When you copy text that has been styled this way, you’ll still get the all caps text instead of the unstyled underlying text. F@$#!



Just don’t .ToUpper your titles. Please. It looks like crap and it’s less readable. And you sound like a Facebook comment from that uncle who ruins Thanksgiving every year.

On dependencies, dependency injection, and sanity

Thu, 24 Mar 2016 23:50:29 GMT

What's interesting about debacles such as the recent left-padding madness is how it can get you to re-think seemingly obvious concepts, and challenge some basic assumptions. Here's in particular a little reflection that just occurred to me on the way between the bathroom and my office, and that may seem super-obvious to some of you. It wasn't to me, so here goes, I'm sharing…

Whether you go all theoretical, call it fancy and talk about "inversion of control", or you just pragmatically do constructor injection like God intended, at this point almost everyone agrees that dependency injection is a Good Idea. You inject a contract, and the black magic inside your IoC container finds the right implementation and gives you an instance, with the right scope, lifetime, etc. Coupling is low, applications are more robust, more modular, more flexible, and unicorns flutter around happily.

Now when you look at the wonderful world of package managers (a clear progress over what the hell we thought we were doing before), what are we doing exactly? Well, we need a component that performs a certain task (in other words, it fulfils a specific contract). We then go on to ask The One True Package Manager to hand us a very specific version of a very specific package. And we do so USING A STRONG NAME. Pardon me for screaming, but can you see the parallel here?

We are "injecting" a "dependency" into our application, but it doesn't for one second occur to us that the concept is almost exactly the same. Let's go over the comparison one more time.

Dependency Injection "dependency" "injection"
Ask for a contract Ask for a strong and versioned package name
Get a managed and scoped instance with members that you can call into Get a set of namespaces with stuff in them that you can call into

So what is good practice on one side (resolution by contract) is completely out of the picture on the other. Why can't we ask for packages by contract? I don't know exactly what that would be looking like, but I have the nagging feeling that there's something to invent here. Or does something like that exist? What do you think?

Easy custom RSS in Orchard

Fri, 26 Feb 2016 20:15:56 GMT

Orchard adds RSS automatically to everything that looks like a list of content items: blog posts, of course, but also comments, projections, lists, search results, tags, etc. I’ve explained before how RSS works internally, but adding a new feed from code can look like a daunting task if you’re not an experienced Orchard developer. Fortunately, there is another feature related to RSS that makes it possible to create custom RSS without writing a line of code. On a default installation of Orchard, let's create a new query that lists all pages in the system (that would be just the home page unless you created more): Then, let's use that in a new projection page: Once this is done, we can navigate to the new projection, and if we look at the rendered HTML, we'll see the following tag in the HEAD that gives us the path to the RSS feed for the query (ID may vary): If we follow that URL, we'll find the default RSS feed: Pages http://localhost:30321/OrchardLocal/pages Pages Welcome to Orchard! http://localhost:30321/OrchardLocal/ Welcome to Orchard! Fri, 26 Feb 2016 16:19:26 GMT http://localhost:30321/OrchardLocal/ If we want to customize this feed, say we want to add taxonomy terms as RSS categories, it is actually possible to do so just from the admin. I'll assume that we have a taxonomy called "Category" in the system, and that we've added the corresponding taxonomy field to the type definition for Page. First, we need to enable the Feeds Tokens feature: Let's head over to the content definition for the Page type and add the RSS part: Now we can configure the part to use our taxonomy as RSS categories: And voilà, our feed now shows categories: Welcome to Orchard! http://localhost:30321/OrchardLocal/ Welcome to Orchard! Fri, 26 Feb 2016 16:19:00 GMT http://localhost:30321/OrchardLocal/ Home Orchard RSS [...]

Why I prefer spaces to tabs

Wed, 20 Jan 2016 23:46:00 GMT

Coding convention discussions are always fun. I just had one of them on the weekly Orchard meeting, where I’ve joked that spaces are objectively superior to tabs, by which I meant that there are objective arguments in favor of spaces that I find subjectively compelling..

The first argument for me is that a good programming font has to be a monospace font. Tabs are weird in that context because they are the only useful characters that are a different width than everything else. If, for whatever reason, you have to replace a space with another character, nothing else will move. If you replace a tab with anything else, the rest of the line will move. Additionally, if you change the tab width in your editor settings, the code will look different to you than to its author.

The second argument is that what you align is not always line beginnings. There are legitimate cases where the beginning of a line is aligned with some boundary inside the previous line. A typical example is a list of arguments for a method that is too long to fit on one line:

It is a legitimate preference to want the additional lines of parameters to align with the opening parenthesis. Tabs can’t do that consistently.

That’s my opinion. Pick your own. As always, what’s important is to set the rules for the project and stick to them…

Liberté, Égalité, Fraternité

Sat, 14 Nov 2015 17:36:00 GMT

They hate joy.

They hate freedom.

They hate peace.

They hate life.

They hate what we are: joyful, free, peaceful, and alive.

So they scream, they enslave, they wage war, and they kill.

They can kill us, but they won’t kill joy, freedom, peace, or life.

We’re stronger.

We stand together.

We are the Human Family.

Open Source is about much more than code contributions

Sat, 31 Oct 2015 17:15:36 GMT

Tell the pointy-haired bosses around the world: putting a GPL sticker on your product is not going to magically make all those nerds in their parent’s basements build it for you, and for free. Nope. Not going to happen. And you know what? The code contributions are not the benefits you’re looking for…

Just to get this out of the way, not all businesses should make their software open source. There are plenty of sensible reasons to keep your code closed (most of which would probably make me look for a different job, but that’s another story). Way worse than keeping your source proprietary however is to open it for the wrong reasons: it’s going to fail, and going back to closed is hard and damaging.

Community really is what you’re looking for, and making your product hackable is the best way to build that. And what better way to make your product hackable than to open it with the most liberal license you can find?

Community means the most loyal customer base you can hope for. Better, it means advocates for your products. Ask Tesla (a pioneer in open hardware in a very conservative industry): here’s a company that has disrupted the car business, without any advertising whatsoever. How? Community: the best Tesla salespeople are Tesla owners. How do you recognize a Tesla owner? You don’t have to, he will fucking tell you. And he’ll give you a ride. And then you’ll want one. So yes, you also need a freaking good product.

The community can help you with that as well, in fact: casual users aren’t going to tell you what sucks in your stuff, they’re just going to move to the competition. Deeply invested, passionate contributors will, because they need and want it to get better.

Building a passionate community is the stuff of dreams for business people, and it’s a very difficult thing to build. But here’s the catch: community is a two-way street. It works much better if it’s not based on a feudal system where the lord in the castle orders the serfs what to do. Nobody’s going to willingly stay in such a community, you’d need a way to coerce them to (not naming names, no sir), and that’s evil, m’kay? No, a healthy community, like a successful marriage, is based on mutual respect and genuine interest in others’ differences, drives, and goals.

If you feel the urge to restrict what your users can do with your code or designs, if you think you should prevent potential competitors from emerging from your user base, then maybe open source is not for you. You should feel comfortable with letting contributors come up with their own reasons to fork your project. It might be to build something amazingly creative that you wouldn’t have thought of in a thousand years, or it might be a clone of your product. Big deal, out-innovate them, capitalize on the rest of the community: nobody wants to use the cheap clone that’s lagging two releases behind.

Here’s another wonderful consequence of the open model: it will help you look beyond myopic profiteering, and build a business model that is more human. It will make you think about what really matters, about why you’re doing whatever it is you’re doing. It will make your life better and more purposeful. True story.

Sprinkling some C#6 fairy dust on FluentPath

Thu, 15 Oct 2015 15:09:00 GMT

I moved my FluentPath library’s source code from CodePlex to GitHub, and while I was at it, I vacuumed a bit, removed the cobwebs, and decided to see what applying some C#6 goodness would do to my code. Usually, I would not advise anyone to touch existing, working code that way just for the sake of using the new features: if it ain’t broke… But I wanted to kick the tires, you know? Just don’t start sending people pull request with that sort of crap, that would just be rude ;)

There were a few places where I was able to replace String.Format with string interpolation, but those are not great examples because those strings should be localizable, ideally, something with which interpolation won’t help much.

The biggest benefit for this library really was using expression-bodied members wherever it made sense. For example, this:

public static T Root {
  get {
    return Create(System.IO.Path.GetPathRoot(Current.ToString()));

Can now be written this way:

public static T Root => Create(System.IO.Path.GetPathRoot(Current.ToString()));

Much terser and easier on the eyes, no?

You can check out the whole changesets here and here.

Orchard Harvest 2015 – Trip Report

Mon, 12 Oct 2015 15:28:00 GMT

It is customary when returning from a conference that we write a trip report and send it to the team. In the spirit of openness that surrounds all things Orchard, I’ve decided that I’d write the trip report for this year’s Orchard Harvest as a public blog post… So here it is… This year’s edition of the conference was the fourth Orchard conference. Harvest is a relatively small, single track conference, with about 60 attendees, and 12 sessions given by 11 speakers over two days. All the talks are professionally recorded, and make their way to YouTube a few weeks after the event. The conference alternates locations between the US and Europe. This year’s conference was held in Alicante, Spain. This was a very pleasant location, with clement weather, and lovely sunrises over the sea. Because the conference happened off-season, the city wasn’t crowded, and everything was very inexpensive. The nightlife in Alicante is what you’d expect from a Mediterranean city. The food is amazing, too. Tapas rule. This is important, because especially for smaller conferences, the main reason to go isn’t the sessions: it’s the networking. The audience for Harvest conferences is composed of core contributors, web agencies, and independent software vendors building on and for Orchard. It’s a crowd that is very personally invested in the success of the platform, wants to see it progress, and wants to exchange and collaborate. During one of my sessions, I asked who had chosen Orchard because it’s running on .NET, and almost everybody in the audience raised their hands, so this crowd is definitely not only attached to Orchard, but also to .NET and C# in general. This is a platform that they love, and that they want to work with it if they get to choose. The sessions made it clear that Orchard is now firmly in the hands of the community, not just by its open governance model, but also by contributions. Although it started as a Microsoft project, its future is now what the community will make of it. There was a question during the panel session about more Microsoft resources devoted to the project in the future (Sébastien Ros is working more or less full-time on Orchard), and more specifically if I would be spending some Microsoft time on it now that I’m back working for the Evil Empire. That was interesting in that at this point, it would really be a nice to have, and something that the community would really appreciate, without fear of unwanted intervention on governance. From this and various conversations I’ve had after the sessions, it seemed clear that the perception of Microsoft with regards to open source has really shifted from being slightly threatening and suspect, to being an appreciated contributor to the ecosystem. To be fair, Microsoft has never been a boogeyman to this particular community, but there seems to be no concerns whatsoever today about this. Let me know in comments if I’m misinterpreting that one. The sessions were all very interesting, and could be classified under three categories: Orchard features and extensions now and in the future, external topics of interest to Orchard users, and case studies. In the features and extensions category, we had: The CMS of the future, where Nick and I talked about the core principles that made Orchard successful as the CMS of the future of 5 years ago, and how those same principles still apply today as we are designing the CMS of today’s future, Orchard 2.0. VNext, where Nick followed up on the keynote to show exactly wh[...]

Orchard Harvest 2015 – ASP.NET MVC 6 Tag Helpers

Tue, 06 Oct 2015 13:59:00 GMT

Taylor Mullen was here to introduce the tag helpers that are going to be added to ASP.NET MVC 6, basically to replace HTML helpers. Tag helpers are html tag-like bits of C# code. Because they are essentially C#, you can get all the benefits of the IDE, such as IntelliSense and refactoring. Out of the box, there will be tag helpers for forms, labels, inputs, that understand additional attributes. For example,

Orchard Harvest 2015 – Orchard for tens of thousands of journalists

Tue, 06 Oct 2015 10:52:00 GMT

Lombiq gave us a case study of Media Kitty, which is a web site with 18,000 users. This is a rewrite of a web site that was previously written with VB and WebForms.

The new site features rich profiles including images, taxonomies, subscriptions, and billing/payment. The contents of the site is then restricted by permissions that depend on subscription levels. The site also has a social network aspect, where users can follow each other, like posts, post private messages, and invite others. Integration to external social networks is also provided.

Layouts and the media library are heavily used. A custom field was built to allow end-users to manage their own media.

They implemented some extensions to placement to enable grouping of shapes (think tabs, as one possible way to present that). It’s even possible to show the same shape under multiple groups. No numeric positioning under groups however.

This being a migration from an existing application, they had to migrate the legacy data, and operate the site, including during the migration.

One of the tools they have built is a way to use Orchard as a framework in an existing application, like VNext will enable, but on the current version. They use that to build a console application running Orchard code (NOT the command-line interface that comes with Orchard).

They also showed some of the tools they have built to better manage Orchard instances on Azure.

They’ve built a module that allows for remote execution of recipes that they use from continuous integration (TeamCity) to trigger configuration changes on new builds.

UPDATE: the video is online.

width="560" height="315" src="" frameborder="0" allowfullscreen="allowfullscreen">