While at NDC Oslo, K Scott and Jon talked to Chris Klug about pragmatically applying SOLID principles and on moving from Silverlight to HTML5.
Download / Listen: Herding Code 208: Chris Klug on SOLID principles and migrating from Silverlight to Angular and TypeScript
- Hello There
- (00:18) Jon says hi to Chris Klug and mispronounces his name and feels bad about it but Chris is understanding and lets it go.
- SOLID principles and Pragmatism
- (00:27) Chris has been doing SOLID talks for a while, but this time he spoke about when to use SOLID principles and when not to. However, open-closed and Liskov substitution principle are both examples that might not fit into all scenarios. Chris says if you go full-SOLID you might never ship anything… and shipping is a good feature, too.
- (01:28) Jon asks Chris if he gets some pushback. Chris says he does, from both sides.
- (02:20) K Scott asks Chris about how he applies the Single Responsibility Principle.
- Migrating from Silverlight to Angular and TypeScript
- (05:44) K Scott asks Chris if he’d always use TypeScript. Chris says maybe not for simple projects, since TypeScript makes things a little more complicated due to the transpiler step. But the type safety’s really nice for any larger project.
- (06:28) Jon says he thinks that Silverlight was a good bridge to HTML5 since it let you get started with things like video on the web long before HTML5 supported them. Chris kind of agrees, but points out that HTML5 video still doesn’t support DRM, and he still prefers XAML to HTML and CSS.
- (08:22) Jon asks what Chris would recommend to developers who are starting on the transition from XAML to HTML5. Chris says just jump in and get started – probably using Angular and TypeScript. It’s really not that hard once you get started.
- Kite surfing and being a rock star
- (09:00) Jon asks Chris what he does for fun in his free time. Chris says he’s a kite boarder, which is a little tricky because he lives in Stockholm.
- (09:42) Jon asks Chris about his picture from the NDC speakers page, and Chris tells the story.
- (10:24) K Scott asks Chris about the best spots he’s been kite boarding, and Chris mentions a few in South Africa.
While at NDC Oslo, K Scott and Jon talked to Damian about ASP.NET 5, running DNX cross-platform (including Raspberry Pi), the exploratory work he and the team are doing to make ASP.NET 5 run really fast, TagHelpers, and his favorite Redmond craft beers.
Download / Listen: Herding Code 207: Damian Edwards on ASP.NET 5, DNX everywhere, and experimental servers on Windows
- (00:18) K Scott asks about the general status of ASP.NET 5 and what Damian’s been up to. Damian mentions the work the team’s been up to and the two talks and two days of workshops he and Jon just completed.
- ASP.NET 5 – portability and cross-platform
- (01:16) K Scott asks about the advantages of running ASP.NET 5 on the Core CLR. Damian says the big advantages are portability (bundle the runtime with your app) and cross-platform – anything beyond that is secondary. It is lighter, more compact, etc., but that’s not the main goal.
- (03:04) Jon talks about how he went through a depressing smackdown trying to talk managers into letting him upgrade corporate apps to ASP.NET 2.0 (when it first came out) and the "one framework per server" monster shut him down. Damian points out that you do lose some things in translations – there are some Windows abstractions and API’s that will only be available in the full CLR. So if you have a requirement for Windows-specific functionality (COM, directory services, etc.), you’ll need to run your application on the full .NET Framework.
- (03:59) K Scott asks about the experience of bundling the runtime with your application. Damian describes how he demonstrated this during his presentation, bundling multiple runtimes (e.g. Linux, Mono, Mac, Windows) with an application.
- (04:38) K Scott asks hosting on Linux. Damian describes Kestrel, the web host for ASP.NET 5 that runs on libuv (used by Node and other servers).
- ASP.NET 5 HTTP Performance, Pipelining and HTTP 2
- (05:50) K Scott asks how Damian expects ASP.NET 5 to perform relative to Node.js. Damian describes the performance testing testing he an his team have started looking at using the TechEmpower benchmarks. He lists several abstractions and implementations they’ve looked at, starting with the simplest benchmark that just tests plaintext response.
- (10:15) Damian explains how pipelining works. K Scott asks about how HTTP 2 fits it. Damian talks about how both enable higher HTTP throughput.
- (12:17) Jon asks if the useful the HTTP plaintext test is and Damian talks about this test focuses on efficiency in speaking HTTP, there are a lot of other tests and features they’ll need to look at as they move up the stack.
- (12:55) K Scott asks why the ASP.NET 5 stack is nearly twice as fast as ASP.NET 4.x for plaintext responses. Damian talks about how legacy compatibility in ASP.NET 4.x extends all the way back to classic ASP, whereas ASP.NET 5 only pulls in specific features as needed by the application.
- (14:44) Damian says they’ll also be looking at massive concurrency (important for realtime applications) and asynchronous background work.
- (15:32) Jon incorrectly guesses that async background work will be important for pipeline scenarios. Damian says that since pipelining only works over the same connection, so this is more relevant for HTTP 2.
- Minimizing Kernel / User Mode Transitions
- (16:56) Jon asks about the importance of switching between kernel and user mode. Damian explains why that transition is necessary and the performance impact it has. He talks about how some of the memory management techniques they’re looking at.
- (21:12) Jon asks about some newer APIs Damian had previously mentioned to him. Damian talks about Registered IO (RIO) in Windows 8 and Windows Server 2012 R2. K Scott asks about HTTP.SYS kernel mode caching.
- (24:07) Jon asks if there are some performance impacts he should pay attention to as a web developer. Damian talks about the process ASP.NET MVC pipeline and how content could be double or triple buffered in some cases as it moved through the pipeline. That’s an issue when you’re looking at client-side optimization, because bytes aren’t flushed to the client as early as possible. In ASP.NET MVC 6, it’s now possible to explicitly flush content, and the double and triple buffering has been removed.
- (27:14) K Scott asks about the baseline KB allocated per request. Damian said that previously it was 15-40 KB per request before your application code did anything; now it’s under a KB. There are some other buffers they can probably pool as well.
- (28:22) Jon asks TagHelpers. Damian explains some of the problems with HTML Helpers, especially when you need to control the HTML that’s being output. TagHelpers allow you to call HTML Helpers using an HTML-like syntax (tags and attributes) so you get all of the benefits of working in the HTML editor.
- What do you do for fun?
- (30:33) K Scott asks Damian what he does for fun. Damian talks about craft beers in Redmond and his new espresso machine. K Scott asks Damian about some of his favorite craft breweries; Damian talks about Kilty MacSporran and Hogus Maximus from Postdoc Brewing and Black Raven Brewing Co.
While at NDC Oslo, K Scott and Jon talked to Rachel about accessibility (web and otherwise) and testing.
Download / Listen: Herding Code 206: Rachel Appel on Accessibility and Unit Testing
- (00:18) Jon starts by asking Rachel what aspects of accessibility she addressed in her talk. Rachel overviews some aspects: visual, auditory, motor and cognitive needs.
- (02:20) Rachel describes how increasing font size on a page is a really quick change that helps a lot of people, pointing out that eyeglasses are an accessibility technology.
- (02:50) Using HTML semantic tags and ARIA attributes help people who are using screen readers to navigate your site – otherwise screen readers have to read through ads, page headers, etc. for every single page.
- (03:45) There are 1.4 billion people with some kind of accessible needs.
- (04:06) K Scott asks how well modern screen readers handle things like semantic HTML markup. Rachel says yes, and also mentions alt tags for images. Jon and Rachel discuss how easy it is to just rename divs to semantic tags like header and nav.
- (05:13) Jon asks what ARIA is. Rachel says it stands for Accessible Rich Internet Applications and describes how ARIA attributes can give hints to screen readers for things like required fields and validation errors.
- (06:44) Rachel recommends that listeners download a screen reader like NVDA or WebAnywhere, blindfold yourself and take some time navigating their sites to understand the experience.
- (07:28) K Scott asks about building SPA sites with technologies like React, Angular, Ember. Rachel says that ARIA elements still work, and there are ARIA and semantic elements that indicate to screen readers that navigation is occurring. K Scott asks if navigation within a SPA causes the screen reader to start over; Rachel says that it does and recommends using skip links. Rachel recommends visiting the accessibility site webaim.org, which shows a good example of using skip links.
- (09:25) Jon asks how Rachel got interested in accessibility. She’s worked on a lot of government sites which require accessibility standards, but she’s just personally interested in making sites that are easy to use. She describes some of the frustrations in browsing websites with ads and modals, then points out that it’s even worse for users with accessible needs. Users with accessible needs make up 20% of the population, so you can easily justify any extra work as worthwhile just in expanding your user base by 20%.
- (12:30) K Scott asks if Rachel has any other resource recommendations. She recommends using the WAVE scanner on the WebAIM site, which indicates a number of issues including contrast.
- Jon asks about color blindness considerations. Rachel says that it’s also important – Facebook is blue because Mark Zuckerberg is colorblind. She recommends using a tool called the Color Oracle. Rachel and K Scott discuss a number of considerations to make sure your sites and applications make sense to users with color blindness issues.
- (15:55) Rachel gave another talk about testing with ASP.NET MVC. She covered xUnit for testing application code, qUnit for front-end testing, and UI automation testing. She recommends starting with unit testing, then adding in front-end and automation testing.
- (16:50) Rachel thinks UI automation testing is kind of a hidden gem – Visual Studio has coded UI tests, which can emulate user actions, which just records your UI interactions so that it can play them back later. K Scott asks about timing issues and Jon asks about use with single page application. Rachel says just consider coded UI tests as a user – you can even have a QA or actual users click through the site and record their actions. K Scott asks what versions of Visual Studio support it. (ed. note: the recorder is only in Visual Studio Enterprise).
- (18:50) K Scott asks what Rachel does to relax when she’s not testing and calling people out for accessibility issues, and Rachel tells us her upcoming travel plans.
While at NDC Oslo, K Scott and Jon caught up with Udi Dahan to discuss his experiences in building a distributed company (Particular Software) to offer support and services for NServiceBus and related technologies.
Download / Listen: Herding Code 205: Udi Dahan on Starting a Company Based on an Open Source Project
- Hello There
- (00:18) K Scott introduces Udi Dahan, whom we last spoke to in 2010.
- Growing from an open source project to commercial product: how and why
- (00:41) Udi describes why he started a company to better support the NServiceBus community. On his own, he wasn’t able to both support himself doing NServiceBus training and the NServiceBus project. He decided he was doing his users a disservice by continuing the free open source model, but he wasn’t sure it would work since there weren’t really precedents for taking an open source project commercial in the .NET world.
- (03:17) K Scott asks Udi about the global reach of his distributed company.
- Commercial Software and Licensing Are Hard
- (04:10) Udi describes the learning curve to start selling a commercial product – complications with contracts, legal issues, etc. Pricing is complicated, too, because companies are structured so differently.
- (06:43) K Scott asks if each customer requires a separate license.
- (07:11) Jon asks what commercial model they settled on. Udi explains that the "call for a quote" model is common for large customers, but for "normal" customers it’s generally $25 per month for a developer machine.
- (08:15) Jon asks what changed with respect to the license and code availability. Udi explains that the code is still on GitHub, the license just changed for cases where it’s being used commercially and developers don’t want to release their code. The code is now under the RPL – the Reciprocal Public License.
- (09:12) Jon asks about the difference between the RPL and the AGPL licenses. Udi explains that AGPL explains that AGPL only requires releasing your code to your users in order to use the code for free, so there’s a loophole for cases like large intranet deployments. RPL requires releasing your code to the world for free use, not just to your users.
- (10:37) Jon says he’s happy to see open source as a thriving business model. Udi clarifies a bit – the common approach is a service based open source model, but this it really pushes you towards working with a few very large customers. The problems with this approach is that you’re both subject to large risk if you lose your giant customers, and you’re competing with enterprise vendors who have deep pockets.
- Running a Distributed Company
- (13:44) K Scott asks Udi how he manages a growing, distributed company. Udi says that it’s good that the growth doesn’t happen all at once.
- (15:15) Jon asks how they handle communications. Udi says it’s important to write everything down and to make use of lots of web conferencing. All web conference meetings are recorded so people can catch up later. Jon says says he thinks that writing everything down makes things easier for your company over time. Udi says he wouldn’t say it’s easier, it’s more of a maturity forcing function – if you’re able to get through it, you’re able to do a lot more and get new employees up to speed a lot faster.
- Surprise Lightning Round!
- (18:43) K Scott springs a surprise Lighting Round on Udi!
- (18:56) Microservices
- (20:27) CQR
- (22:03) Event Sourcing
- (26:43) K Scott asks what Udi does to relax in his spare time. Udi says he’s got four kids, which isn’t necessarily relaxing but definitely occupies his free time.
The guys talk to Sara J. Chipps and Geroge Stocker about Jewelbots: smart jewelry for a smarter generation.
Note: They were called Jewliebots when the podcast was recorded, but were since renamed to Jewelbots.
Download / Listen: Herding Code 204: Sara Chipps and George Stocker on Jewelbots
- Hello There
- (00:55) Sara and George introduce themselves and how they got involved in Jewelbots.
- Jewelbot Features and Platform
- (02:12) K Scott asks what Jewelbots is all about. Jewelbots are programable wearables for teenage girls. They’re friendship bracelets that help them learn how to code. K Scott remarks that they’re not just wearables that track the number of steps taken each day, and Sara says from their interviews, teenage girls couldn’t care less about that. Out of the box, they have communication and friendship features, but they’re open source so they can be extended to do things like let them know when they have a new Instagram follower or when their mom is on the way. There will be code snippets available to allow them to get started by copy / paste, then to share code they’ve writing. There will be a repository on GitHub for sharing and collaboration.
- (05:06) K Scott asks how they decided on this platform. Sara talks about how they were inspired by Minecraft, and how they saw young people learning Java so they could write their own mods. They talked to over 100 girls, and learned that some of their initial assumptions were horribly wrong.
- (05:55) Jon asks what was horribly wrong about their assumptions, and Sara says that just having jewelry change color to match their clothes wasn’t that exciting to them – they’re really interested in their friends and friend groups. You configure them to react to your friends and friend groups.
- Hardware Specifics
- (08:00) Kevin asks what it’s like from a coding perspective. Sara says it’s based on Arduino, so you can use the Arduino library on the bracelet to control the Bluetooth, microprocessor, LEDs and motor. George says the code for the predefined APIs will be available so girls can consult the existing code to see how things were built.
- (08:50) K Scott asks if Bluetooth is used to detect nearby friends. Sara explains that it’s a mesh Bluetooth network (something they’ve patented) that allows the bracelets to work without requiring their phones with them.
- (09:15) Scott asks why they didn’t use RFID instead of Bluetooth. Sara explains that RFID only works for a few inches, whereas Bluetooth gives them 30 to 50 feed.
- (10:10) Jon asks if it’s possible to extend the software, or to connect other devices via Bluetooth.
- (11:22) Sara explains that the actual hardware is in a small disk, so it is possible that it could be applied to other use cases.
- (12:25) K Scott asks what was the hardest part about developing it. Sara explains that hardware is so much more difficult than software, and how it’s so much harder to change things later.
- (13:28) Jon asks about the power and battery life. Sara explains the bracelet stand that can charge via USB charger and says they’re still figuring out the battery life.
- (14:32) Scott says they should build in kinetic charging and and asks about adding in sensors. Sara says that for size and cost constraints they decided to leave out sensors.
- (15:35) Scott asks if they’re 3D printing them themselves, or working with sweatshops in New Jersey. Sara says they’re working with PCH and will be manufacturing in China for production, but they’re currently working with local manufacturers for small runs.
- (16:54) Jon asks what hardware is onboard. Sara runs down the list: a microprocessor / Bluetooth unit that’s 4mm square, a motor, 4 LEDs, and a button and a battery. George says that the button can be used for a lot of things, including morse code or other codes they come up with.
- Cost, Funding and Kickstarter
- (18:59) Jon asks how much they’ll cost. Sara says they’re shooting for $60 but it will vary based on a lot of factors. They targeted $60 as it’s the cost of a video game.
- (19:58) Scott has another product suggestion: a backpack locator that shows hot / cold on the LEDs.
- (20:19) Kevin asks about how they got started from a funding perspective. Sara talks about the funding history and hardware projects are more costly.
- (21:26) Jon says Jewelbots sounds like something he’d see on Kickstarter. Sara says that they’re planning to launch a Kickstarter soon, but they want to get the Jewelbot cost figured out first. There’s the obligatory discussion of Kickstarter successes and failures. Scott says that the companies that already have their production pipeline figured out before launching are a lot more successful than vague "I have a dream" Kickstarters. Sara says they’ve also heard that you really need to have your costs figured out before launching a Kickstarter.
- The First Rule of Introducing Girls To Coding: Don’t Call It Coding
- (24:50) Kevin asks if there are concerns that the Arduino IDE may be too low level, and if they might make an easier onramp. Sara says they don’t think they’ll convert every young girl into a coder, but they’ll help a lot of them to look at code in a way they haven’t before. One important thing they’ve learned is not to call it coding as that scares a lot of people off. Sara says that the opposite of maker is not girly – they want to make being a maker accessible. So if a small percentage actually become coders but the rest just become more comfortable with the idea of coding and engineering, they’ll have accomplished their goal. Sara talks about Super Awesome Sylvia – a 13 year old girl who does all kinds of cool things with Arduinos.
- Getting Started With Hardware… And Just How Hard Is Hardware, Anyway?
- (27:22) Kevin asks how Sara made the jump from software to hardware. Sara talks about her introduction by Emily Rose (@nexxylove) at Node Dublin 2012 with a bullfighting drone and an out of control fog machine, and she was hooked on the spot. She started with getting LEDs to light up – the hardware equivalent of Hello World – and went from there.
- (29:30) Scott talks about how much more you have to think about with hardware as compared to software, and how it’s probably a good exercise for software developers to think differently about how they write their code. George talks about how he’s new to hardware, and how power drain and battery life concerns made them think about things like haptic motor startup and different power consumption for different color LEDs.
- Important Questions In Random Order, e.g. Charging, Release Date, the Phone App, and Piglets
- (31:43) Jon asks for more info on the charging connection. Sara explains the 4 touchpoints on the charger which are used to both charge the bracelet and upload code to the device. Scott asks if they considered using Bluetooth; Sara says that they had and the Bluetooth chip allows for that, but since many of their target users use desktops they didn’t want to require Bluetooth for data transfer.
- (32:40) Jon asks if they’re continuing to do user testing. Sara says that they’re doing that constantly, and it’s been really important.
- (33:45) Kevin asks how soon they’ll be shipping, and Sara says hoping to ship by late 2015 / early 2016.
- (34:24) Jon asks if they’re experimenting different charm designs with 3D printing. Sara says they’re using injeciton molding for the charms, and that Jewelbots will ship with a default charm and band but they’re interchangeable so they’re expecting and encouraging people to make them their own.
- (35:35) George talks about the phone app which allows for more of an if-this-then-that style of programming, which will be simpler.
- (36:32) There’s a question on twitter about Sara’s thoughts on piglets.
- (37:27) Jon asks for more details about the phone app. George says it’s an Android and iOS app that allows you to add new friends and set up how your Jewelbot should react if you’re around different friend groups. He explains a bit more about how things are stored on the bracelet, the phone app, and a central web server.
- (39:14) K Scott asks how devices are identified so you can select your friends. George says you’ll identify yourself when you set up the device and standard Bluetooth pairing handles connections. He talks about how some of the Bluetooth things they’re doing use new parts of the BLE spec that nobody’s done yet, so they’re figuring things out.
- (40:18) Jon asks if it’s possible to do firmware updates. Sara says that the Bluetooth chip they’re using allows for over the air updates, so they can distribute firmware updates to all devices from Jewelbot Central. George talks about the complications in the hardware world you don’t think about in the software world – for instance, someone can decide not to take a firmware update, so you have to make sure things still work even if they don’t take firmware updates.
- (41:20) Sara says that Jewelbots will not help parents find their daughters. You’ll need to manage that yourself.
- Important Things You Should Click On
- (41:43) Sara talks about the upcoming Kickstarter as well as the (now available) Quire campaign so you can be part of their growth and part of their company.
The guys talk to Rob Eisenberg about Aurelia.
Download / Listen: Herding Code 203: Rob Eisenberg on Aurelia
- [Sponsor Message]
- Hello There
- (01:15) Kevin introduces Rob.
- (02:05) Kevin asks Rob about his Xaml platform work with Caliburn.Micro. Rob says he’s transferred that work to Nigel Sampson, and it’s alive and well.
- Comparing Aurelia with Angular
- (05:25) Rob also wanted to target transpiled languages so it worked well with ES6, ES5, TypeScript and Coffeescript. By comparison, Angular was pretty focused on Dart and AtScript.
- (06:12) Jon references Rob’s post comparing Angular and Aurelia code and asks about conventions. Rob describes how conventions work, how you can create your own conventions, and how you can override conventions by providing metadata (but only for overrides, not all the time).
- (08:56) Rob describes how binding and the templating syntax work. Aurelia minimizes additional markup for binding, whereas he sees Angular syntax focused on theoretical tooling experiences that could be built, but nobody’s committed to. Also, while Angular’s syntax is technically valid, it doesn’t work with cases like SVG. There’s a secondary binding syntax to work around that, but having two syntax doesn’t seem like a clean solution.
- (12:31) Kevin asks for examples of conventions in Aurelia. Rob explains how custom elements work with EcmaScript 6 modules and exports. No metadata is required, as compared to Angular which requires specifying metadata in all cases even if you’re not using them. Rob also explains custom attributes (again using a simple exported class). Naming conventions set up the mappings so no metadata is required. Value converters are yet another example – the naming convention assumes that any class ending in ValueConverter is automatically registered and configured.
- (16:43) Rob says that in Angular you need to declare all directives you’re using in your view models. That really bugs Rob because the implementation details in the view shouldn’t be reflected in the viewmodel. That was required for lazy loading, but he sees it as a design problem and a maintenance problem. Rob says that Aurelia uses an import in the view and doesn’t touch the viewmodel, using the EcmaScript 6 loader. Rob says that this design makes some conventions impossible.
- The Aurelia Pitch
- (21:08) Scott K says he likes the class-based design in Aurelia and asks Rob for a quick pitch for Aurelia to sell it to a team. Rob talks about the clean, standards based design that allows decomposing complex screens without requiring extra configuration. It’s easy to build, extend and maintain. Rob also talks about the binding syntax, and the ability to plug in other binding strategies by dropping in an adapter. The binding strategy system has been tested out with Breeze.js and Knockout, allowing you to use your existing models without requiring unnecessary dirty checks.
- (26:42) Scott K asks how object.observe works with tranpilers. Rob says there’s a polyfill that generates getter / setter pairs if object.observe isn’t available. Rob explains how this works with the micro task queue, and how it allows for queued tasks to handle queued work efficiently. Rob talks about the task-queue in Aurelia, and how it can be used outside of Aurelia as well. Rather than directly observing DOM elements, the task queue allows for batching changes for efficiency.
- (35:15) Kevin asks if Aurelia handles a persistence layer. Rob says that rather than building that, they’ve worked to make it easy to plug popular persistence libraries in. He also discusses the validation system they’re working on.
- (38:22) Jon asks if Rob’s looked at PouchDb and references Herding Code 181, in which Max Thayer explained PouchDb.
- Why not write my own framework?
- SVG use
- (44:40) Jon asks if Rob thinks people will use SVG. Rob says it’s more about building a production-quality framework, then gives some possible usecases like graphs, mapping and custom elements. Rob says that people do all kinds of things you might not expect when they use a framework, and building a real framework requires it. Kevin says at his last job they’d started converting image sprites to SVG, and it was a pretty good use-case.
- (49:05) Kevin asks about Rob’s thoughts on React. He says it’s a good renderer, but it’s not a framework. He and Scott K agree that React is a library, not a framework. Rob says he wrote a blog post in which a custom Aurelia element uses React as a custom renderer. The Babel transpiler allows mixing JSX with ES6 code, and this allows continuing to use Aurelia binding. In general, Rob says really smart, but if you need a framework you’ll end up cobbling a bunch of things together to use it. Instead, he’d recommend using a framework like Aurelia and just pulling in React when it’s required.
- (53:22) Kevin asks if Rob’s considered adding a virtual DOM to Aurelia. Rob says it’s not clear that there would be an advantage in most cases.
- Isomorphic rendering
- Questions from Twitter
- (57:25) Question from Twitter (@cecilphillip): "What’s the rendering perf like compared to ReactJS?" Rob says that React is going to be a lot faster for initial render time, whereas Aurelia is probably going to be faster for updates. It’s hard to give an accurate comparison; Rob says they’re mostly focused on being fast enough rather than the fastest. He says Aurelia’s not slow now, but they’re focusing on some upcoming performance enhancements that he’s expecting big results from.
- (1:02:09) Question from Twitter (@csharpfritz): "can you talk about what lead to the choice of architecture with JSPM?" Rob explains how JSPM integrates package management with module loading. Aurelia isn’t directly dependent on JSPM, so you can use other package managers and loaders if you want. Jon says the one thing he wants JSPM to integrate rate limiting so he doesn’t hit the GitHub rate limit; Rob says this is being addressed in a future release since most cases don’t require the hitting the rate limited API.
- Scott K’s Packaging Rant(tm)
- (1:08:11) Scott K has a "short rant" about NPM, JSPM and all package managers in general: they all use existing config files (like gitconfig) and should be tested behind corporate firewalls and proxies. And then there’s the nested package thing, which doesn’t work well on Windows due to path length limits. Jon says he uses the flatten-packages package. There’s a short group rant about the file path length limit on Windows.
- Final questions and wrapup
- (1:13:40) Jon asks if there are any patterns or thoughts on server-side development for Aurelia. Rob says there are starter kits on the way, and people are using Aurelia with lots of back ends (.NET, node, MEAN, etc.). He talks about samples on the way, including a Todo app (even though he thinks Todo apps aren’t useful for application frameworks).
- (1:17:15) Kevin asks where Aurelia’s at in a release cycle. Rob says it’s currently in preview / alpha phase but targeting a beta around June or later. Don’t go to production with it now, but get ready for the release after that.