<?xml version="1.0" encoding="utf-8" standalone="yes" ?>
<rss version="2.0" xmlns:atom="http://www.w3.org/2005/Atom">
  <channel>
    <title>Home on The Log Book of Manuel Kießling</title>
    <link>https://manuel.kiessling.net/</link>
    <description>Recent content in Home on The Log Book of Manuel Kießling</description>
    <generator>Hugo -- gohugo.io</generator>
    <lastBuildDate>Thu, 29 Jan 2026 00:00:01 +0100</lastBuildDate>
    
	<atom:link href="https://manuel.kiessling.net/index.xml" rel="self" type="application/rss+xml" />
    
    
    <item>
      <title>About</title>
      <link>https://manuel.kiessling.net/about/</link>
      <pubDate>Mon, 01 Jan 0001 00:00:00 +0000</pubDate>
      
      <guid>https://manuel.kiessling.net/about/</guid>
      <description>This is the homepage and blog of Manuel Kießling.
I&amp;rsquo;m a software architect, programmer, Linux and AWS admin, book author, and father of two.
You can write me an e-mail at manuel@kiessling.net, or find me on Twitter, GitHub, Xing, and LinkedIn.</description>
    </item>
    
    <item>
      <title>SiteBuilder Remote Assets: Cross-Vertical Architecture and S3 Integration</title>
      <link>https://manuel.kiessling.net/2026/01/29/sitebuilder-remote-assets-architecture/</link>
      <pubDate>Thu, 29 Jan 2026 00:00:01 +0100</pubDate>
      
      <guid>https://manuel.kiessling.net/2026/01/29/sitebuilder-remote-assets-architecture/</guid>
      <description>Describe in chat → see the result → changes land in a GitHub PR. The full loop.
SiteBuilder is an open-source tool that lets non-technical teams edit web content through chat while engineers keep Git workflows and full control. Marketing describes changes in plain language; an AI agent makes the edits; every change goes through a pull request for review. This post is a technical deep-dive — if you&amp;rsquo;re new to SiteBuilder, the introductory post covers the problem it solves and how it works.</description>
    </item>
    
    <item>
      <title>SiteBuilder Architecture Insights: Agent Tools and Execution Context</title>
      <link>https://manuel.kiessling.net/2026/01/26/sitebuilder-agent-architecture-insights/</link>
      <pubDate>Mon, 26 Jan 2026 00:00:01 +0100</pubDate>
      
      <guid>https://manuel.kiessling.net/2026/01/26/sitebuilder-agent-architecture-insights/</guid>
      <description>Describe in chat → see the result → changes land in a GitHub PR. The full loop.
SiteBuilder is an open-source tool that lets non-technical teams edit web content through chat while engineers keep Git workflows and full control. Marketing describes changes in plain language; an AI agent makes the edits; every change goes through a pull request for review. This post is a technical follow-up — if you&amp;rsquo;re new to SiteBuilder, the introductory post covers the problem it solves and how it works.</description>
    </item>
    
    <item>
      <title>Introducing SiteBuilder: Edit Web Content with Natural Language</title>
      <link>https://manuel.kiessling.net/2026/01/25/introducing-sitebuilder/</link>
      <pubDate>Sun, 25 Jan 2026 00:00:01 +0100</pubDate>
      
      <guid>https://manuel.kiessling.net/2026/01/25/introducing-sitebuilder/</guid>
      <description>Describe in chat → see the result → changes land in a GitHub PR. The full loop.
The Problem Here&amp;rsquo;s a situation that will sound familiar to many engineering teams: the marketing department needs to change a headline on the website. Or update a phone number. Or tweak some copy before a campaign goes live.
What happens next? A ticket is filed. An engineer context-switches away from actual engineering work.</description>
    </item>
    
    <item>
      <title>What if software shipped with a software engineer?</title>
      <link>https://manuel.kiessling.net/2025/11/04/what-if-software-shipped-with-a-software-engineer/</link>
      <pubDate>Tue, 04 Nov 2025 00:00:01 +0200</pubDate>
      
      <guid>https://manuel.kiessling.net/2025/11/04/what-if-software-shipped-with-a-software-engineer/</guid>
      <description>A recent experiment made the rounds showing an LLM acting as the whole application: every HTTP request is handled by the model, that designs schemas, renders HTML, and mutates state through tool calls: “Why write code if the LLM can just do the thing?”.
It worked — barely. It was slow, expensive, and visually inconsistent. But it surfaced a useful question: if inference keeps getting cheaper and faster, why generate code at all?</description>
    </item>
    
    <item>
      <title>Introducing MCP as a Service: an open MCP server management platform</title>
      <link>https://manuel.kiessling.net/2025/09/16/introducing-mcp-as-a-service/</link>
      <pubDate>Tue, 16 Sep 2025 00:00:01 +0200</pubDate>
      
      <guid>https://manuel.kiessling.net/2025/09/16/introducing-mcp-as-a-service/</guid>
      <description>Introduction &amp;amp; Context Over the last months I have been building MCP as a Service — an open platform with the goal to allow for deploying and operating MCP servers without having to think about infrastructure.
The goal is simple: give AI agents a reliable way to use real tools through MCP servers that you can launch in seconds, observe visually, secure properly, and connect from anywhere.
MCP as a Service is available to self‑host under a Fair‑code model and as a hosted service you can try for free.</description>
    </item>
    
    <item>
      <title>New Open Source project: An AI-Friendly Static Landing Page Generator</title>
      <link>https://manuel.kiessling.net/2025/04/17/new-open-source-project-landinpage-ai-template/</link>
      <pubDate>Thu, 17 Apr 2025 00:00:01 +0203</pubDate>
      
      <guid>https://manuel.kiessling.net/2025/04/17/new-open-source-project-landinpage-ai-template/</guid>
      <description>Build Static Landing Pages Faster, Especially with AI Creating effective marketing and product landing pages often involves repetitive setup: configuring build tools, defining reusable components, and establishing a consistent style. While AI coding assistants can accelerate HTML and CSS generation, achieving quality and consistency requires a solid foundation.
Manually building this foundation for each new page is inefficient. To streamline this process, especially when working with AI tools, I&amp;rsquo;ve created and open-sourced landingpages-ai-template.</description>
    </item>
    
    <item>
      <title>Senior Developer Skills in the AI Age: Leveraging Experience for Better Results</title>
      <link>https://manuel.kiessling.net/2025/03/31/how-seasoned-developers-can-achieve-great-results-with-ai-coding-agents/</link>
      <pubDate>Thu, 03 Apr 2025 00:00:01 +0203</pubDate>
      
      <guid>https://manuel.kiessling.net/2025/03/31/how-seasoned-developers-can-achieve-great-results-with-ai-coding-agents/</guid>
      <description>Abstract Embedded into powerful IDEs like Cursor, large-language models are now able to act as effective Coding Assistants that can significantly enhance the output and abilities of professional software engineering teams.
However, ending up with the desired functional and non-functional results, as well as an acceptable code quality, is not something that will take care of itself.
Together with my team at work, I have encountered worthwhile use cases where Coding Assistants shine, and identified practices and approaches that help significantly with reaching the intended outcomes at a sufficient quality level.</description>
    </item>
    
    <item>
      <title>New project: Platform Problem Monitoring</title>
      <link>https://manuel.kiessling.net/2025/03/09/new-project-plaform-problem-monitoring/</link>
      <pubDate>Sun, 09 Mar 2025 00:00:01 +0203</pubDate>
      
      <guid>https://manuel.kiessling.net/2025/03/09/new-project-plaform-problem-monitoring/</guid>
      <description>Introducing Platform Problem Monitoring I&amp;rsquo;d like to share a new open-source project I&amp;rsquo;ve been working on: Platform Problem Monitoring. In essence, it&amp;rsquo;s a powerful tool that helps DevOps and platform engineering teams understand what&amp;rsquo;s going wrong in their systems without active effort or manual analysis.
The Problem If you&amp;rsquo;re running a complex platform with many components, you&amp;rsquo;re likely already collecting logs in an ELK (Elasticsearch, Logstash, Kibana) stack. But there&amp;rsquo;s a fundamental challenge with this approach: the sheer volume of data makes it difficult to separate signal from noise.</description>
    </item>
    
    <item>
      <title>Cost and performance optimization of Amazon Athena through data partitioning</title>
      <link>https://manuel.kiessling.net/2024/09/30/cost-and-performance-optimization-of-amazon-athena-through-data-partitioning/</link>
      <pubDate>Mon, 30 Sep 2024 00:00:01 +0200</pubDate>
      
      <guid>https://manuel.kiessling.net/2024/09/30/cost-and-performance-optimization-of-amazon-athena-through-data-partitioning/</guid>
      <description>Introduction &amp;amp; Context At JOBOO we work in a highly data-driven manner, with all of our application platforms continuously streaming so-called event data records to our data warehouse.
Each of these records encapsulates a relevant event from the areas
 Business (&amp;ldquo;a new user signed up&amp;rdquo;, &amp;ldquo;a user has taken out a subscription&amp;rdquo;) Application (&amp;ldquo;an email was sent to a user&amp;rdquo;, &amp;ldquo;an error occurred&amp;rdquo;) Web request (&amp;ldquo;Page X was requested with these and those parameters&amp;rdquo;) and Conversion tracking (&amp;ldquo;user has reached a campaign goal&amp;rdquo;).</description>
    </item>
    
    <item>
      <title>Kosten- und Performance-Optimierung von Amazon Athena durch Daten-Partitionierung</title>
      <link>https://manuel.kiessling.net/2024/09/30/kosten-und-performance-optimierung-von-amazon-athena-durch-daten-partitionierung/</link>
      <pubDate>Mon, 30 Sep 2024 00:00:01 +0200</pubDate>
      
      <guid>https://manuel.kiessling.net/2024/09/30/kosten-und-performance-optimierung-von-amazon-athena-durch-daten-partitionierung/</guid>
      <description>Einführung &amp;amp; Kontext Bei JOBOO arbeiten wir stark datengetrieben, indem alle unsere Anwendungsplattformen sogenannte Event-Daten kontinuierlich an unser Data Warehouse streamen.
Jeder dieser Event-Datensätze kapselt dabei ein relevantes Ereignis aus den Bereichen
 Geschäftsvorfälle (&amp;ldquo;ein User hat sich registriert&amp;rdquo;, &amp;ldquo;ein User hat ein Abonnement abgeschlossen&amp;rdquo;) Anwendung (&amp;ldquo;einem User wurde eine E-Mail zugestellt&amp;rdquo;, &amp;ldquo;ein Fehler ist aufgetreten&amp;rdquo;) Webaufruf (&amp;ldquo;Seite X wurde mit diesen und jenen Parametern aufgerufen&amp;rdquo;) und Conversion-Tracking (&amp;ldquo;User hat ein Kampagnenziel erreicht&amp;rdquo;).</description>
    </item>
    
    <item>
      <title>Node &amp; React Beginner Tutorial — Part 3: Node.js: JavaScript on the command line</title>
      <link>https://manuel.kiessling.net/node-and-react-beginner-tutorial/part-3/</link>
      <pubDate>Thu, 02 May 2024 00:00:03 +0100</pubDate>
      
      <guid>https://manuel.kiessling.net/node-and-react-beginner-tutorial/part-3/</guid>
      <description>This is part three of a multi-part tutorial series that teaches how to build real-world software applications with JavaScript, TypeScript, Node.js, and React — starting from zero knowledge, all the way to launching into production.
Go to Part 1: Introduction to JavaScript to start at the beginning.
Part 3: Node.js: JavaScript on the command line A new context As stated before, running JavaScript code, and therefore, building JavaScript applications, is possible in several different contexts.</description>
    </item>
    
    <item>
      <title>Node &amp; React Beginner Tutorial — Part 2: Storing values</title>
      <link>https://manuel.kiessling.net/node-and-react-beginner-tutorial/part-2/</link>
      <pubDate>Thu, 02 May 2024 00:00:02 +0100</pubDate>
      
      <guid>https://manuel.kiessling.net/node-and-react-beginner-tutorial/part-2/</guid>
      <description>This is part two of a multi-part tutorial series that teaches how to build real-world software applications with JavaScript, TypeScript, Node.js, and React — starting from zero knowledge, all the way to launching into production.
See Part 1: Introduction to JavaScript if you haven&amp;rsquo;t read it yet.
Part 2: Storing values Variables Let&amp;rsquo;s now write a more complex JavaScript expression. Please enter and run let a = &amp;quot;hello&amp;quot; in the console.</description>
    </item>
    
    <item>
      <title>Node &amp; React Beginner Tutorial — Part 1: Introduction to JavaScript</title>
      <link>https://manuel.kiessling.net/node-and-react-beginner-tutorial/part-1/</link>
      <pubDate>Thu, 02 May 2024 00:00:01 +0100</pubDate>
      
      <guid>https://manuel.kiessling.net/node-and-react-beginner-tutorial/part-1/</guid>
      <description>Preface What you will learn The approach of this tutorial is to teach its readers how to build a fully working software application from zero to production.
This means two things:
 You are not required to have done any kind of software development before getting started with this tutorial. It will introduce and explain everything that is needed to build applications in full detail, assuming no prior knowledge or experience.</description>
    </item>
    
    <item>
      <title>Getting rid of temporary failures in name resolution on Amazon Elastic Compute Cloud</title>
      <link>https://manuel.kiessling.net/2022/01/27/getting-rid-of-temporary-failures-in-name-resolution-on-aws-ec2/</link>
      <pubDate>Sat, 22 Jan 2022 16:37:00 +0100</pubDate>
      
      <guid>https://manuel.kiessling.net/2022/01/27/getting-rid-of-temporary-failures-in-name-resolution-on-aws-ec2/</guid>
      <description>Introduction At Joboo.de, we are running nearly all of our production infrastructure on AWS. This includes several web applications running on virtualized Linux servers hosted via EC2.
A couple of weeks ago, we saw elevated error levels from these applications, and they all boiled down to the same problem: in order to connect to some of our AWS-managed services like MariaDB (on AWS Relational Database Service), ElasticSearch (on AWS OpenSearch), SMTP (on AWS Simple Email Service), and Redis (on AWS ElastiCache), the applications wanted to resolve the DNS names of those service endpoints to their underlying IP addresses – and these lookups failed multiple times per day.</description>
    </item>
    
    <item>
      <title>Tutorial: Single Page Applications with a Serverless Backend and Infrastructure as Code</title>
      <link>https://manuel.kiessling.net/2021/05/02/tutorial-react-single-page-applications-spa-with-a-serverless-aws-api-gateway-and-lambda-and-dynamodb-backend-and-terraform-infrastructure-as-code/</link>
      <pubDate>Sun, 02 May 2021 08:30:00 +0100</pubDate>
      
      <guid>https://manuel.kiessling.net/2021/05/02/tutorial-react-single-page-applications-spa-with-a-serverless-aws-api-gateway-and-lambda-and-dynamodb-backend-and-terraform-infrastructure-as-code/</guid>
      <description>About From zero to production: this extensive guide describes in detail how to create and deploy a React-based web app frontend using TypeScript and Redux Toolkit on top of a Node.js based AWS Lambda backend with a DynamoDB database, connect and integrate them through API Gateway and CloudFront, and explains how to codify and automate the required cloud infrastructure and deployment process using Terraform.
Background One of my current tasks at Joboo.</description>
    </item>
    
    <item>
      <title>January 2021 Reading Recommendations</title>
      <link>https://manuel.kiessling.net/2021/01/14/january-2021-reading-recommendations/</link>
      <pubDate>Thu, 14 Jan 2021 09:46:00 +0200</pubDate>
      
      <guid>https://manuel.kiessling.net/2021/01/14/january-2021-reading-recommendations/</guid>
      <description>Books The Rise and Fall of American Growth: The U.S. Standard of Living Since the Civil War  
In the century after the Civil War, an economic revolution improved the American standard of living in ways previously unimaginable. Electric lighting, indoor plumbing, motor vehicles, air travel, and television transformed households and workplaces. But has that era of unprecedented growth come to an end?
Weaving together a vivid narrative, historical anecdotes, and economic analysis, The Rise and Fall of American Growth challenges the view that economic growth will continue unabated, and demonstrates that the life-altering scale of innovations between 1870 and 1970 cannot be repeated.</description>
    </item>
    
    <item>
      <title>Single Sign-On and Resource Separation on AWS</title>
      <link>https://manuel.kiessling.net/2020/12/29/single-sign-on-and-resource-separation-on-aws/</link>
      <pubDate>Tue, 29 Dec 2020 12:50:00 +0100</pubDate>
      
      <guid>https://manuel.kiessling.net/2020/12/29/single-sign-on-and-resource-separation-on-aws/</guid>
      <description>Introduction Most AWS projects start small and simple, with just a single AWS account that contains all the resources and services to build, deploy, and run one or more software projects. Up to a certain point, this is just fine. And even with just one account, resources can be isolated from each other – for example, you can run the EC2 instances of your preproduction stage in a different VPC than the instances of your production stage.</description>
    </item>
    
    <item>
      <title>Die Metapher der Stadt für das Bauen und Betreiben von Softwareprodukten</title>
      <link>https://manuel.kiessling.net/2018/11/25/metapher-stadt-fuer-bauen-und-betreiben-von-software-produkten/</link>
      <pubDate>Sun, 25 Nov 2018 13:21:00 +0100</pubDate>
      
      <guid>https://manuel.kiessling.net/2018/11/25/metapher-stadt-fuer-bauen-und-betreiben-von-software-produkten/</guid>
      <description>In der Branche des Softwarebauens wird gerne mit Metaphern gearbeitet, um die eigene Tätigkeit anschaulich und greifbar zu machen.
Dazu gehört auch, den handelnden Personen verschiedene Rollen zuzuweisen. Klassische Beispiele sind die Software-ArchitektInnen, die ähnlich den ArchitektInnen von Bauwerken das große Ganze im Blick haben sollen und dafür zuständig sind, grobe bis detaillierte Pläne und Rahmenbedingungen aufzustellen, in deren Grenzen solide Softwareprodukte einerseits möglichst effizient gebaut werden können, durch die aber andererseits einfache Erweiterungsfähigkeit, eine langfristige Stabilität im Betrieb, gute Wartbarkeit und hohe Sicherheit dieser Softwareprodukte gewährleistet sein soll.</description>
    </item>
    
    <item>
      <title>Wie Studien verdreht werden</title>
      <link>https://manuel.kiessling.net/2018/11/13/wie-studien-verdreht-werden/</link>
      <pubDate>Tue, 13 Nov 2018 08:12:00 +0100</pubDate>
      
      <guid>https://manuel.kiessling.net/2018/11/13/wie-studien-verdreht-werden/</guid>
      <description>Ein schönes Beispiel für professionell gemachte Fake News - oder zumindest grobe Fahrlässigkeit - findet sich unter https://unserplanet.net/e-autos-dreckig.
Das Ganze ist auch verbreitet als Facebook-Post unter https://www.facebook.com/unserplanet/videos/188402545408094, unter Einbindung eines grob thematisch verwandten Videos von ZDF heuteplus (dessen Wahrheitsgehalt ich hier nicht beurteilen kann und will).
Der verlinkte Artikel sagt:
&amp;ldquo;Eine aktuelle Studie, die vom Trancik Lab des Massachusetts Institute of Technology (MIT) veröffentlicht wurde, hat jedoch ergeben, dass Elektroautos NICHT so grün sind, wie Sie denken und eigentlich schlimmere Umweltverschmutzer sind als Benzin- und Dieselautos.</description>
    </item>
    
    <item>
      <title>March 2018 Book Recommendations</title>
      <link>https://manuel.kiessling.net/2018/03/28/march-2018-book-recommendations/</link>
      <pubDate>Wed, 28 Mar 2018 21:46:00 +0200</pubDate>
      
      <guid>https://manuel.kiessling.net/2018/03/28/march-2018-book-recommendations/</guid>
      <description>The Anatomy of Peace – Second Edition  What if in our conflicts with others there is something we want more than solutions? What if conflicts at home, conflicts at work, and conflicts in the world stem from the same root cause? And what if individually and collectively we systematically misunderstand that cause, and unwittingly perpetuate the very problems we think we are trying to solve? These are among the important questions explored in The Anatomy of Peace.</description>
    </item>
    
    <item>
      <title>How Cassandra&#39;s inner workings relate to performance</title>
      <link>https://manuel.kiessling.net/2016/07/11/how-cassandras-inner-workings-relate-to-performance/</link>
      <pubDate>Mon, 11 Jul 2016 16:13:00 +0100</pubDate>
      
      <guid>https://manuel.kiessling.net/2016/07/11/how-cassandras-inner-workings-relate-to-performance/</guid>
      <description>This is a cross post from the GALERIA Kaufhof Technology Blog.
About At Galeria.de, we learned the hard way that it&#39;s critical to understand the inner workings of the distributed masterless database Cassandra if one wants to experience good performance during reads and writes. This post describes some of the details of how Cassandra works under the hood, and shows how understanding these details helps to anticipate which use patterns work well and which don&#39;t.</description>
    </item>
    
    <item>
      <title>Scala Play2: Tolerant JSON body parsing with dedicated error handling</title>
      <link>https://manuel.kiessling.net/2016/05/16/scala-play2-tolerant-json-body-parsing-with-dedicated-error-handling/</link>
      <pubDate>Mon, 16 May 2016 16:13:00 +0100</pubDate>
      
      <guid>https://manuel.kiessling.net/2016/05/16/scala-play2-tolerant-json-body-parsing-with-dedicated-error-handling/</guid>
      <description>I&#39;m currently rewriting a Scala Play2 based web service that employs the following body parser:  def tolerantJsonParser[A](implicit reader: Reads[A]): BodyParser[A] = parse.tolerantJson.validate(json = json.validate[A].asEither.left.map(err = Results.BadRequest) )(play.api.libs.iteratee.Execution.Implicits.trampoline) def doSomething = Action.async(tolerantJsonParser[SomeThing]) { request = val someThing: SomeThing = request.body ...  Not shown here is the implicit Reads that takes care of transforming the Json object into an object of case class SomeThing when the json.validate method is called.</description>
    </item>
    
    <item>
      <title>Scala: Traversing a graph in a functional way</title>
      <link>https://manuel.kiessling.net/2016/02/15/scala-traversing-a-graph-in-a-functional-way/</link>
      <pubDate>Mon, 15 Feb 2016 16:13:00 +0100</pubDate>
      
      <guid>https://manuel.kiessling.net/2016/02/15/scala-traversing-a-graph-in-a-functional-way/</guid>
      <description>I recently played around with graphs and tried to implement Depth-First Search in a functional and recursive way.  In the following examples we are talking about the following simple directed unweighted graph with vertices a to e:   (click to enlarge)  Each vertex is represented by an object of the following class:  class Vertex() { val name: Char val edges: Set[Vertex] }  Let&#39;s start with an approach that is neither functional nor recursive, but at least straight-forward:  def dfsMutableIterative(start: Vertex): Set[Vertex] = { var current: Vertex = start val found: mutable.</description>
    </item>
    
    <item>
      <title>Puppet: Evaluating defined types for each element in an array in a non-brittle way</title>
      <link>https://manuel.kiessling.net/2016/02/04/puppet-evaluating-defined-types-for-each-element-in-an-array-in-a-non-brittle-way/</link>
      <pubDate>Thu, 04 Feb 2016 16:13:00 +0100</pubDate>
      
      <guid>https://manuel.kiessling.net/2016/02/04/puppet-evaluating-defined-types-for-each-element-in-an-array-in-a-non-brittle-way/</guid>
      <description>In one of the JourneyMonitor puppet manifests, we have a defined type that allows us to dynamically create cronjob files on target machines:  define createCronjobFile { file { &#34;/etc/cron.d/journeymonitor-${name}&#34;: owner =&amp;gt; &#34;root&#34;, group =&amp;gt; &#34;root&#34;, mode =&amp;gt; &#34;0644&#34;, content =&amp;gt; template(&#34;cronjobs/etc/cron.d/journeymonitor-${name}.erb&#34;), } } 
 Let’s assume that we have a system where we want to end up having cronjobs /etc/cron.d/journeymonitor-foo and /etc/cron.d/journeymonitor-bar.  This is achieved by defining an array in Hiera like this:  cronjobs: - foo - bar</description>
    </item>
    
    <item>
      <title>Compile Time Cassandra Injection in Play 2.4</title>
      <link>https://manuel.kiessling.net/2016/01/17/compile-time-cassandra-injection-in-play-2-4/</link>
      <pubDate>Sun, 17 Jan 2016 16:13:00 +0100</pubDate>
      
      <guid>https://manuel.kiessling.net/2016/01/17/compile-time-cassandra-injection-in-play-2-4/</guid>
      <description>About  Play 2.4 supports Compile Time Dependency Injection. This post describes how to inject your own Cassandra repository object into a controller at compile time, while also initializing and closing a Cassandra connection session during application startup and shutdown, respectively.  The code of the final application is available at https://github.com/manuelkiessling/play2-compiletime-cassandra-di. The goal  At the end of this post, we have created a small Play 2.4.6 Scala application with which will be able to serve the name of a product with a given id by reading information from a Cassandra database.</description>
    </item>
    
    <item>
      <title>Video: Die E-Commerce-Welt bei GALERIA Kaufhof</title>
      <link>https://manuel.kiessling.net/2016/01/07/video-die-arbeitswelt-bei-galeria-de/</link>
      <pubDate>Thu, 07 Jan 2016 16:13:00 +0100</pubDate>
      
      <guid>https://manuel.kiessling.net/2016/01/07/video-die-arbeitswelt-bei-galeria-de/</guid>
      <description> Das Personalmarketing der GALERIA Kaufhof GmbH hat einen wie ich finde sehr ansprechend gemachten Film zur Arbeitswelt im E-Commerce Bereich des Unternehmens drehen lassen, der unser Motto Wir ♥ E-Commerce! anschaulich macht. Mit dabei meine Kollegen Beate Radics, Rico Pfaus, und ich.   </description>
    </item>
    
    <item>
      <title>Die Architektur der Galeria.de Plattform im Kontext der Produktentwicklungs-Organisation</title>
      <link>https://manuel.kiessling.net/2016/01/02/die-architektur-der-galeria-de-plattform-im-kontext-der-produktentwicklungsorganisation/</link>
      <pubDate>Sat, 02 Jan 2016 16:13:00 +0100</pubDate>
      
      <guid>https://manuel.kiessling.net/2016/01/02/die-architektur-der-galeria-de-plattform-im-kontext-der-produktentwicklungsorganisation/</guid>
      <description>Über diesen Artikel Im Kontext des GALERIA Kaufhof Technology Blogs stellt der vorliegende Artikel ein Update und eine Erweiterung des Beitrags von September 2014 dar.
Schon damals existierte ein klar definiertes Set an Vorgaben, welches den Rahmen für Makro- und Mikroarchitekturfragen gesteckt hat und das Projekt in Hinblick auf Fragen der System- und Softwarearchitektur leitet.
In den vergangenen Tagen haben wir begonnen, ausgehend von den Erfahrungen bis heute und unserer jetzigen Perspektive, einige der Grundlagen unserer Architektur noch einmal neu aufzuschreiben.</description>
    </item>
    
    <item>
      <title>Play2: Switching from specs2 to ScalaTest</title>
      <link>https://manuel.kiessling.net/2015/12/31/play2-switching-from-specs2-to-scalatest/</link>
      <pubDate>Thu, 31 Dec 2015 16:13:00 +0100</pubDate>
      
      <guid>https://manuel.kiessling.net/2015/12/31/play2-switching-from-specs2-to-scalatest/</guid>
      <description>The following applies to Play 2.4 projects for Scala 2.11.  When setting up a Play2 Scala project, two test case files are created automatically: test/ApplicationSpec.scala and test/IntegrationSpec.scala. The testcases therein are based on specs2. If you prefer to write your test cases using ScalaTest (I certainly do), then you need to proceed as follow:  Change the libraryDependencies in file build.sbt from:  libraryDependencies ++= Seq( jdbc, cache, ws, specs2 % Test )</description>
    </item>
    
    <item>
      <title>Adding a Play2 application as a sub-project to an existing sbt project</title>
      <link>https://manuel.kiessling.net/2015/12/09/adding-a-play2-application-as-a-sub-project-to-an-existing-sbt-project/</link>
      <pubDate>Wed, 09 Dec 2015 16:13:00 +0100</pubDate>
      
      <guid>https://manuel.kiessling.net/2015/12/09/adding-a-play2-application-as-a-sub-project-to-an-existing-sbt-project/</guid>
      <description>About this post  Already working on an sbt-based Scala project with two sub-projects, I wanted to create a third sub-project, a Play2 application. The following describes what worked for me. Creating the sub-project structure  Before adding the third sub-project, my sbt project structure looked like this:  importer/ └ src/ ├ main/ └ test/ spark/ └ src/ ├ main/ └ test/ project/ └ plugins.sbt build.sbt 
 Within build.</description>
    </item>
    
    <item>
      <title>Upgrading a Symfony project from 2.6 to 3.0</title>
      <link>https://manuel.kiessling.net/2015/12/07/upgrading-a-symfony-project-from-2-6-to-3-0/</link>
      <pubDate>Mon, 07 Dec 2015 16:13:00 +0100</pubDate>
      
      <guid>https://manuel.kiessling.net/2015/12/07/upgrading-a-symfony-project-from-2-6-to-3-0/</guid>
      <description>About this post  Symfony 3.0 has been released recently, and I wanted to upgrade my side project JourneyMonitor, which was still based on Symfony 2.6, as quickly as possible.  This post explains how I approached the upgrade, and shows which parts of the project structure and code had to be changed in order to get the project working again. Preparing the upgrade  The code base for the project – the CONTROL component of the JourneyMonitor project – lives at https://github.</description>
    </item>
    
    <item>
      <title>Entwicklung und Betrieb einer Symfony2 Webanwendung – Teil 1</title>
      <link>https://manuel.kiessling.net/2015/11/29/entwicklung-und-betrieb-einer-symfony2-webanwendung-teil-1/</link>
      <pubDate>Sun, 29 Nov 2015 16:13:00 +0100</pubDate>
      
      <guid>https://manuel.kiessling.net/2015/11/29/entwicklung-und-betrieb-einer-symfony2-webanwendung-teil-1/</guid>
      <description>Über diesen Artikel  Dies ist ein Crosspost vom GALERIA Kaufhof Technology Blog. Vor kurzem standen wir vor der Herausforderung, eine kleine Onlineanwendung für eine zeitlich begrenzte Rabattaktion zu realisieren, die keinerlei Verbindung mit dem Galeria.de Webshop hatte.
Während der Technologiestack rund um unseren Onlineshop auf Scala, Ruby und Casssandra basiert, wurde hier die Entscheidung gefällt, die Anwendung außerhalb unserer bestehenden Dienste und Systeme zu realisieren, und auch nicht im Kontext unserer Scala und Ruby Teams, mit dem Ziel den normalen Produktentwicklungsprozess nicht mit diesem Sonderprojekt zu “stören”.</description>
    </item>
    
    <item>
      <title>Setting up an sbt-based project for Scala 2.11 with ScalaTest support</title>
      <link>https://manuel.kiessling.net/2015/11/02/setting-up-an-sbt-based-project-for-scala-2-11-with-scalatest-support/</link>
      <pubDate>Mon, 02 Nov 2015 16:13:00 +0100</pubDate>
      
      <guid>https://manuel.kiessling.net/2015/11/02/setting-up-an-sbt-based-project-for-scala-2-11-with-scalatest-support/</guid>
      <description>This post describes how to set up a new Scala 2.11.7 project with ScalaTest 2.2.4 support using sbt 0.13.9 on Mac OS X 10.11 “El Capitan” with Java 1.8.  If set up as describes below, you can manage your project via sbt, and you will be able to run your test cases via sbt test. Also, after setting things up this way, the project can be opened and used in IntelliJ IDEA 14 as an sbt project.</description>
    </item>
    
    <item>
      <title>How I build, deploy, and run Spark</title>
      <link>https://manuel.kiessling.net/2015/10/17/how-i-build-deploy-and-run-spark/</link>
      <pubDate>Sat, 17 Oct 2015 16:13:00 +0100</pubDate>
      
      <guid>https://manuel.kiessling.net/2015/10/17/how-i-build-deploy-and-run-spark/</guid>
      <description>I’m currently tinkering with Spark for my side project JourneyMonitor. The goal is to extract useful metrics from the Selenium runs executed by the platform.  To do so, I’m currently in the process of creating a new Analyze component. I want to build the Spark setup and the jobs using Scala 2.11. Therefore, I had to compile my own version of Spark 1.5.1, put it onto the systems, and run a cluster from that.</description>
    </item>
    
    <item>
      <title>Interview: Die E-Commerce-Plattform von GALERIA Kaufhof</title>
      <link>https://manuel.kiessling.net/2015/07/09/interview-die-e-commerce-plattform-von-galeria-kaufhof/</link>
      <pubDate>Thu, 09 Jul 2015 16:13:00 +0100</pubDate>
      
      <guid>https://manuel.kiessling.net/2015/07/09/interview-die-e-commerce-plattform-von-galeria-kaufhof/</guid>
      <description> In Ausgabe #23 der ShopTechTalks unterhält sich Roman Zenner mit Michael Wegener (talentformation GmbH) und mir über die selbst entwickelte E-Commerce-Plattform von GALERIA Kaufhof. Wir berichten unter anderem über die nötigen Schritte von einer monolithischen Shop-Lösung, die primär von einem externen Dienstleister weiterentwickelt und gepflegt wurde hin zu einem verteilten System, an dem interne Teams arbeiten:   </description>
    </item>
    
    <item>
      <title>Transformieren und Validieren von JSON Requests in Play2</title>
      <link>https://manuel.kiessling.net/2015/03/01/transformieren-und-validieren-von-json-requests-in-play2/</link>
      <pubDate>Sun, 01 Mar 2015 16:13:00 +0100</pubDate>
      
      <guid>https://manuel.kiessling.net/2015/03/01/transformieren-und-validieren-von-json-requests-in-play2/</guid>
      <description>Dies ist ein Crosspost vom Galeria Kaufhof Technology Blog.
Als Anfänger in der Arbeit mit Scala stehe ich aktuell vor der Aufgabe, eine einfache Webservice API in Play2 zu realisieren.
Der Webservice hat einen Endpunkt /api/experiments, über den via POST ein A/B Test (bzw. Experiment) mit 2 oder mehr Varianten angelegt werden kann.
Der Body eines solchen Requests ist eine JSON Struktur, die den A/B Test beschreibt:
{ &#34;name&#34;: &#34;Checkout page buttons&#34;</description>
    </item>
    
    <item>
      <title>Things you should not read, Vol. 2</title>
      <link>https://manuel.kiessling.net/2015/01/20/things-you-should-not-read-vol-2/</link>
      <pubDate>Tue, 20 Jan 2015 16:13:00 +0100</pubDate>
      
      <guid>https://manuel.kiessling.net/2015/01/20/things-you-should-not-read-vol-2/</guid>
      <description> Please do not read this, this, this, this, and this. </description>
    </item>
    
    <item>
      <title>Setting up a Scala sbt multi-project with Cassandra connectivity and migrations</title>
      <link>https://manuel.kiessling.net/2015/01/19/setting-up-a-scala-sbt-multi-project-with-cassandra-connectivity-and-migrations/</link>
      <pubDate>Mon, 19 Jan 2015 16:13:00 +0100</pubDate>
      
      <guid>https://manuel.kiessling.net/2015/01/19/setting-up-a-scala-sbt-multi-project-with-cassandra-connectivity-and-migrations/</guid>
      <description>This is a cross-post from the official Galeria Kaufhof Technology Blog
I have learned the following through the great support and advice of my coworkers Jens Müller and Martin Grotzke.
About I have recently joined the new multi-channel retail eCommerce project at Galeria Kaufhof in Cologne. This meant diving head-first into a large-scale Scala/Play/Akka/Ruby software ecosystem, and as a consequence, a lot of learning (and unlearning, and disorientation, and some first small successes), as I’m still quite new to Scala.</description>
    </item>
    
    <item>
      <title>Things you should not read, Vol. 1</title>
      <link>https://manuel.kiessling.net/2015/01/09/things-you-should-not-read-vol-1/</link>
      <pubDate>Fri, 09 Jan 2015 16:13:00 +0100</pubDate>
      
      <guid>https://manuel.kiessling.net/2015/01/09/things-you-should-not-read-vol-1/</guid>
      <description> Please do not read this, this, this, this, and this. </description>
    </item>
    
    <item>
      <title>Limiting access to forwarded ports in Cisco iOS</title>
      <link>https://manuel.kiessling.net/2014/06/20/limiting-access-to-forwarded-ports-in-cisco-ios/</link>
      <pubDate>Fri, 20 Jun 2014 16:13:00 +0100</pubDate>
      
      <guid>https://manuel.kiessling.net/2014/06/20/limiting-access-to-forwarded-ports-in-cisco-ios/</guid>
      <description>The following should probably be obvious, but I had a surprisingly hard time figuring out the official Cisco documentation.  The scenario is as follows: a gateway Cisco router provides internet access via NAT for, say, your office. It therefore has an external interface (called Dialer0, for example) which is connected to the uplink (this could e.g. be a DSL line), and an internal ethernet interface connected to the internal office network:   ^ | | Dialer0: 87.</description>
    </item>
    
    <item>
      <title>Creating a useful AngularJS project structure and toolchain</title>
      <link>https://manuel.kiessling.net/2014/06/09/creating-a-useful-angularjs-project-structure-and-toolchain/</link>
      <pubDate>Mon, 09 Jun 2014 16:13:00 +0100</pubDate>
      
      <guid>https://manuel.kiessling.net/2014/06/09/creating-a-useful-angularjs-project-structure-and-toolchain/</guid>
      <description>About  This article describes in great detail what I learned about setting up AngularJS applications in terms of project structure, tools, dependency management, test automation and code distribution. The result is a seed project that is easily extendable, clearly structured, self-documenting, and comfortable to work with. Requirements  One of the key points of this setup is that everything that is needed for the application itself to run and the tests to works, and every other relevant task related to developing the application, is pulled in through tool-based dependency management.</description>
    </item>
    
    <item>
      <title>Mocking Dependencies in PHP Unit Tests with Mockery</title>
      <link>https://manuel.kiessling.net/2014/05/08/mocking-dependencies-in-php-unit-tests-with-mockery/</link>
      <pubDate>Thu, 08 May 2014 16:13:00 +0100</pubDate>
      
      <guid>https://manuel.kiessling.net/2014/05/08/mocking-dependencies-in-php-unit-tests-with-mockery/</guid>
      <description>The following solution is based on the work of my coworker Marcel Frank.  The PHP library Mockery allows to use a simulated version of certain objects within unit tests, where objects are passed into methods as dependencies. This form of simulation is called mocking.  Instead of trying to explain why simulating these objects in the tests makes sense, I will try to illustrate the need for it with an example.</description>
    </item>
    
    <item>
      <title>Building manageable server infrastructures with Puppet: Part 1</title>
      <link>https://manuel.kiessling.net/2014/03/26/building-manageable-server-infrastructures-with-puppet-part-1/</link>
      <pubDate>Wed, 26 Mar 2014 16:13:00 +0100</pubDate>
      
      <guid>https://manuel.kiessling.net/2014/03/26/building-manageable-server-infrastructures-with-puppet-part-1/</guid>
      <description>About  With this series I would like to provide a comprehensive hands-on tutorial that explains step-by-step how to build a centrally managed Linux server infrastructure using Puppet. Target audience  I believe that the readers who will get most out of this series are Linux systems administrators who already manage a small-sized network of server systems and wonder how they can grow the existing infrastructure – without having to grow the amount of time and effort put into managing these systems linearly with the number of new systems.</description>
    </item>
    
    <item>
      <title>Building manageable server infrastructures with Puppet: Part 2</title>
      <link>https://manuel.kiessling.net/2014/03/26/building-manageable-server-infrastructures-with-puppet-part-2/</link>
      <pubDate>Wed, 26 Mar 2014 15:13:00 +0100</pubDate>
      
      <guid>https://manuel.kiessling.net/2014/03/26/building-manageable-server-infrastructures-with-puppet-part-2/</guid>
      <description>About  In Part 1 of Building manageable server infrastructures with Puppet, we have set up two virtual Linux systems, a puppetserver and a puppetclient. We reached an important first milestone: We installed and set up the Puppet server and Puppet client software on their respective machines, and we authenticated the Puppet client with the Puppet server. We are now going to use this setup to start configuring our puppetclient system through the Puppet server on the puppetserver system.</description>
    </item>
    
    <item>
      <title>Building manageable server infrastructures with Puppet: Part 3</title>
      <link>https://manuel.kiessling.net/2014/03/26/building-manageable-server-infrastructures-with-puppet-part-3/</link>
      <pubDate>Wed, 26 Mar 2014 14:13:00 +0100</pubDate>
      
      <guid>https://manuel.kiessling.net/2014/03/26/building-manageable-server-infrastructures-with-puppet-part-3/</guid>
      <description>About  In Part 2 of Building manageable server infrastructures with Puppet, we started to configure our puppetclient machine by writing a first, simple manifest on the Puppet master. We are now going to look at more complex configuration setups and we’ll learn how to put our manifests into a useful structure. Modules  Keeping the managed configuration for a server infrastructure in just one file won’t scale well once this infrastructure grows beyond a handful of systems.</description>
    </item>
    
    <item>
      <title>Building manageable server infrastructures with Puppet: Part 4</title>
      <link>https://manuel.kiessling.net/2014/03/26/building-manageable-server-infrastructures-with-puppet-part-4/</link>
      <pubDate>Wed, 26 Mar 2014 13:13:00 +0100</pubDate>
      
      <guid>https://manuel.kiessling.net/2014/03/26/building-manageable-server-infrastructures-with-puppet-part-4/</guid>
      <description>About  In Part 3 of Building manageable server infrastructures with Puppet, we created our first reusable real-world Puppet module, apache2. In part 4 and following, we will stop using examples and start building a fully featured infrastructure with users and rights management, Nagios monitoring, file servers, load balancers, web servers, databases, VPN, development systems et cetera. Managing user and group accounts through Puppet  At the company I work for, I use Puppet to manage the Unix user accounts of me and my coworkers on our Linux machines.</description>
    </item>
    
    <item>
      <title>Converting a running physical machine into a KVM virtual machine</title>
      <link>https://manuel.kiessling.net/2013/03/19/converting-a-running-physical-machine-to-a-kvm-virtual-machine/</link>
      <pubDate>Tue, 19 Mar 2013 13:13:00 +0100</pubDate>
      
      <guid>https://manuel.kiessling.net/2013/03/19/converting-a-running-physical-machine-to-a-kvm-virtual-machine/</guid>
      <description>Let’s assume you have a physical machine running a Linux system, and you would like to convert this system into a virtual KVM/QEMU machine, keeping everything as close to the original as possible. What follows is my approach.  The first thing we need is a raw image file which mirrors the exact layout of the physical hard drive in our physical server.  In our example scenario, the physical box has one hard drive at /dev/sda with a /boot Partition on /dev/sda2 and a physical LVM volume on /dev/sda3.</description>
    </item>
    
    <item>
      <title>Software-RAIDs unter Linux mittels md</title>
      <link>https://manuel.kiessling.net/2012/11/13/software-raids-unter-linux-mittels-md/</link>
      <pubDate>Tue, 13 Nov 2012 16:13:00 +0100</pubDate>
      
      <guid>https://manuel.kiessling.net/2012/11/13/software-raids-unter-linux-mittels-md/</guid>
      <description>Über das md Modul („Multiple Device driver“) verfügt der Linux-Kernel bereits seit geraumer Zeit über einen äußerst soliden Treiber, um rein softwaregesteuerte Festplatten-RAIDs zu konstruieren.
Diese Software-RAIDs bringen zwar nicht die Performance eines dedizierten hochwertigen Hardware-RAID-Controllers mit, sind aber definitiv mehr als eine Notlösung. Die Benchmarks am Ende des Artikels zeigen, dass sich zumindest für ein strukturell einfaches RAID1-Setup keine praktisch relevanten Performanceeinbußen messen lassen.
Im folgenden wird beschrieben, wie man ein Software-RAID1 unter Ubuntu 12.</description>
    </item>
    
    <item>
      <title>Direktes mounten eines KVM RAW Images</title>
      <link>https://manuel.kiessling.net/2012/10/31/direktes-mounten-eines-kvm-raw-images/</link>
      <pubDate>Wed, 31 Oct 2012 16:13:00 +0100</pubDate>
      
      <guid>https://manuel.kiessling.net/2012/10/31/direktes-mounten-eines-kvm-raw-images/</guid>
      <description>Ich habe ein mir weitgehend unbekanntes RAW Image eines KVM-Gastes, und möchte auf die darin vorhandenen Partitionen direkt zugreifen, d.h. ich will sie auf dem KVM Host einmounten.
Dies geht mit folgendem Kommando:
mount -t ext4 -o loop,offset=OFFSET /var/lib/libvirt/images/foo.raw /mnt  Das Problem ist der Offset – es ist eine Byte-Angabe die dem Mount-Befehl sagt, an welcher Stelle in der RAW Datei die Partition beginnt. Diese Zahl muss man zuerst ermitteln.</description>
    </item>
    
    <item>
      <title>KVM Gäste über WLAN ins Netz bringen</title>
      <link>https://manuel.kiessling.net/2012/10/31/kvm-gaeste-ueber-wlan-ins-netz-bringen/</link>
      <pubDate>Wed, 31 Oct 2012 16:13:00 +0100</pubDate>
      
      <guid>https://manuel.kiessling.net/2012/10/31/kvm-gaeste-ueber-wlan-ins-netz-bringen/</guid>
      <description>Folgende Situation: Ihr habt einen KVM-Host, auf dem mehrere virtuelle Maschinen laufen. Diese sind alle mit einer Bridge verbunden, die auf dem Host eingerichtet wurde, wobei eth0 ein Teil dieser Bridge ist:
~# brctl show bridge name	bridge id	STP enabled	interfaces lan0	8000.dc0ea1540a0e	no	eth0 vnet0 vnet1  Soweit, so gewöhnlich. Was aber, wenn der Zugang zum Internet auf dem Host nicht über eth0 erfolgt, sondern über eine WLAN-Verbindung? In diesem Fall kommen die KVM-Gäste über die Bridge zwar an alle Hosts, die entweder Teil der Bridge sind oder an eth0 hängen, sie gelangen aber nicht ins Internet.</description>
    </item>
    
    <item>
      <title>Desktop Ubuntu zu Server downgraden</title>
      <link>https://manuel.kiessling.net/2012/10/24/desktop-ubuntu-zu-server-downgraden/</link>
      <pubDate>Wed, 24 Oct 2012 16:13:00 +0100</pubDate>
      
      <guid>https://manuel.kiessling.net/2012/10/24/desktop-ubuntu-zu-server-downgraden/</guid>
      <description>Aus Versehen Ubuntu Desktop installiert, jetzt soll&amp;rsquo;s aber doch ein Server werden? So wird man die grafische Oberfläche komplett los:
apt-get remove \ --purge \ whoopsie \ network-manager \ lightdm \ ubuntu-desktop \ unity* \ gnome* \ xserver-xorg-core xserver-xorg compiz-kde compizconfig-backend-kconfig kdelibs5-data libattica0.3 libdlrestrictions1 libkdecore5 libkdeui5 apt-get --purge autoremove  </description>
    </item>
    
    <item>
      <title>Mit virt-install virtuelle KVM Maschinen an der Textkonsole ohne VNC installieren</title>
      <link>https://manuel.kiessling.net/2012/10/24/mit-virt-install-virtuelle-kvm-maschinen-an-der-textkonsole-ohne-vnc-installieren/</link>
      <pubDate>Wed, 24 Oct 2012 16:13:00 +0100</pubDate>
      
      <guid>https://manuel.kiessling.net/2012/10/24/mit-virt-install-virtuelle-kvm-maschinen-an-der-textkonsole-ohne-vnc-installieren/</guid>
      <description>Die meisten KVM bzw. virt-install Tutorials erwecken den Eindruck, dass man virtuelle Maschinen zwar an der Konsole neu erstellen kann, sich dann aber via VNC in diese verbinden muss, um die Installation durchzuführen. Es geht aber auch komplett textbasiert, d.h. man muss die laufende SSH Session mit dem KVM Host nicht einmal unterbrechen. Einzige Voraussetzung ist natürlich, dass der zu installierende KVM Gast überhaupt eine textbasierte Installation erlaubt. Getestet habe ich es mit einem Ubuntu 12.</description>
    </item>
    
    <item>
      <title>Using virt-install to create virtual KVM machines on the text console without using VNC</title>
      <link>https://manuel.kiessling.net/2012/10/24/using-virt-install-to-create-virtual-kvm-machines-on-the-text-console-without-using-vnc/</link>
      <pubDate>Wed, 24 Oct 2012 16:13:00 +0100</pubDate>
      
      <guid>https://manuel.kiessling.net/2012/10/24/using-virt-install-to-create-virtual-kvm-machines-on-the-text-console-without-using-vnc/</guid>
      <description>Most KVM or virt-install tutorials will make you think that while you can create new virtual guests on the text console, you still have to log into them using VNC in order to actually use their OS installation tools. But in fact there is a way to completely install new guests without leaving your SSH session – as long as the guest OS does have a text-based installer, that it. I have tested this with an Ubuntu 12.</description>
    </item>
    
    <item>
      <title>Window Maker unter Ubuntu 12.10 Quantal Quetzal</title>
      <link>https://manuel.kiessling.net/2012/10/22/window-maker-unter-ubuntu-12-10-quantal-quetzal/</link>
      <pubDate>Mon, 22 Oct 2012 16:13:00 +0100</pubDate>
      
      <guid>https://manuel.kiessling.net/2012/10/22/window-maker-unter-ubuntu-12-10-quantal-quetzal/</guid>
      <description>Privat benutze ich ein sehr einfaches aber praktisches Acer Aspire One 722, dies ist ein günstiges 11,6 Zoll Netbook mit einer 1GHz AMD CPU. Das System ist nicht gerade ein Rennpferd, aber das muss es für meine Ansprüche auch nicht sein – im Wesentlichen beschränken sich 95% meiner Nutzung auf Browser und Konsole, letztere in Form des wunderbaren Guake.
Als Betriebssystem verwende ich aktuell Ubuntu 12.10 Quantal Quetzal, und hier liegt das Problem: Unity ist einfach zu schwergewichtig, um auf diesem schmalbrüstigen Rechner Spaß zu machen, und die leichtgewichtigen Alternativen wie Xubuntu oder Lubuntu habe ich als wenig stabil erlebt.</description>
    </item>
    
    <item>
      <title>Bash: Skriptausgaben mit Zeitstempel versehen</title>
      <link>https://manuel.kiessling.net/2012/10/18/bash-skriptausgaben-mit-zeitstempel-versehen/</link>
      <pubDate>Thu, 18 Oct 2012 16:13:00 +0100</pubDate>
      
      <guid>https://manuel.kiessling.net/2012/10/18/bash-skriptausgaben-mit-zeitstempel-versehen/</guid>
      <description>Sowohl selbstgeschriebene als auch fremde Applikationen für die Linuxkonsole schreiben häufig Ausgaben nach STDOUT, zum Beispiel, um über den Fortschritt ihrer Operationen zu berichten:
Starte Foo... Foo beendet. Beginne mit Migration... Element 1 migriert... Element 2 migriert... Element 3 migriert... Migration abgeschlossen.  Richtet man solche Skripte als regelmäßige Batchläufe über cron ein, leitet man diese Ausgaben vielleicht in eine Datei um, so dass man über Logfiles der Batchläufe verfügt:</description>
    </item>
    
    <item>
      <title>Applying The Clean Architecture to Go applications</title>
      <link>https://manuel.kiessling.net/2012/09/28/applying-the-clean-architecture-to-go-applications/</link>
      <pubDate>Fri, 28 Sep 2012 13:13:00 +0100</pubDate>
      
      <guid>https://manuel.kiessling.net/2012/09/28/applying-the-clean-architecture-to-go-applications/</guid>
      <description>What this text is about  I would like to contribute to Uncle Bob’s concept of The Clean Architecture by demonstrating how its principles could be applied to an actual Go application. It doesn’t make much sense to completely rephrase Uncle Bob’s blog post here, thus reading his text first is definitely a prerequisite for understanding mine.  In it, he mainly describes the Dependency Rule, which, when applied to an architecture where different areas of the software are organized as circles within other circles, says “…that source code dependencies can only point inwards.</description>
    </item>
    
    <item>
      <title>Tutorial: Developing HTML5 Canvas Games for Facebook with JavaScript</title>
      <link>https://manuel.kiessling.net/2012/04/02/tutorial-developing-html5-canvas-games-for-facebook-with-javascript-part-1/</link>
      <pubDate>Mon, 02 Apr 2012 13:13:00 +0100</pubDate>
      
      <guid>https://manuel.kiessling.net/2012/04/02/tutorial-developing-html5-canvas-games-for-facebook-with-javascript-part-1/</guid>
      <description>This is a multi-part tutorial series. You are currently reading part 1.  Some days ago, my son asked me how computer games are made. He’s five years old and couldn’t quite imagine how games are created, because “you can’t just paint them like animation movies, can you?”.  I quickly realized that explaining it to a child is really difficult. And so I decided to create a game, with him as the Creative Director who decides what the game should be like.</description>
    </item>
    
    <item>
      <title>“We need to work longer” – Why this is not what you want to say</title>
      <link>https://manuel.kiessling.net/2012/04/02/we-need-to-work-longer-why-this-is-not-what-you-want-to-say/</link>
      <pubDate>Mon, 02 Apr 2012 13:13:00 +0100</pubDate>
      
      <guid>https://manuel.kiessling.net/2012/04/02/we-need-to-work-longer-why-this-is-not-what-you-want-to-say/</guid>
      <description>Every now and then, a manager at your company might say something like “We need to work longer” or “Our people need to work longer”.  Here’s why I don’t think it is a good idea to say this.  Well, first of all, there may really be the need for people to change something about their work, and so the motivation and the goal of the manager might be valid and important.</description>
    </item>
    
    <item>
      <title>True universal JavaScript modules with write-once-run-anywhere Jasmine specs</title>
      <link>https://manuel.kiessling.net/2012/03/30/true-universal-javascript-modules-with-write-once-run-anywhere-jasmine-specs/</link>
      <pubDate>Fri, 30 Mar 2012 13:13:00 +0100</pubDate>
      
      <guid>https://manuel.kiessling.net/2012/03/30/true-universal-javascript-modules-with-write-once-run-anywhere-jasmine-specs/</guid>
      <description>As a JavaScript developer writing general-purpose libraries, you probably wish you could go fully universal, that is, you might want to create a library:  that can be used in the browser and in Node.js – without any hacks for either platform, and without code-duplication that transparently utilizes AMD via RequireJS in the browser and CommonJS via require in Node.js – without any hacks for either platform, and without code-duplication with a Jasmine spec suite which runs in the browser and in Node.</description>
    </item>
    
    <item>
      <title>Talk: PHP 5.4 – die wichtigsten Neuerungen im Überblick</title>
      <link>https://manuel.kiessling.net/2012/03/24/talk-php-5-4-die-wichtigsten-neuerungen-im-ueberblick/</link>
      <pubDate>Sat, 24 Mar 2012 13:13:00 +0100</pubDate>
      
      <guid>https://manuel.kiessling.net/2012/03/24/talk-php-5-4-die-wichtigsten-neuerungen-im-ueberblick/</guid>
      <description> Am 14. März 2012 fand das erste Treffen der Symfony User Group Berlin statt. Ich habe dort einen kurzen Talk mit dem Titel PHP 5.4 – die wichtigsten Neuerungen im Überblick gehalten. Die Folien des Talks gibt es hier zum Download als PDF und hier bei Slideshare. Einen Videomitschnitt gibt es bei Ustream. PHP 5.4: Die wichtigsten Neuerungen im Überblick  View more PowerPoint from Manuel Kießling    </description>
    </item>
    
    <item>
      <title>Object-orientation and inheritance in JavaScript: a comprehensive explanation</title>
      <link>https://manuel.kiessling.net/2012/03/23/object-orientation-and-inheritance-in-javascript-a-comprehensive-explanation/</link>
      <pubDate>Fri, 23 Mar 2012 16:13:00 +0100</pubDate>
      
      <guid>https://manuel.kiessling.net/2012/03/23/object-orientation-and-inheritance-in-javascript-a-comprehensive-explanation/</guid>
      <description>Let’s talk about object-orientation and inheritance in JavaScript.
The good news is that it’s actually quite simple, but the bad news is that it works completely different than object-orientation in languages like C++, Java, Ruby, Python or PHP, making it not-quite-so simple to understand.
But fear not, we are going to take it step by step.
Blueprints versus finger-pointing Let’s start by looking at how &#34;typical&#34; object-oriented languages actually create objects.</description>
    </item>
    
    <item>
      <title>Project: projectile, an HTML5 canvas game</title>
      <link>https://manuel.kiessling.net/2012/03/19/project-projectile-an-html5-canvas-game/</link>
      <pubDate>Mon, 19 Mar 2012 16:13:00 +0100</pubDate>
      
      <guid>https://manuel.kiessling.net/2012/03/19/project-projectile-an-html5-canvas-game/</guid>
      <description>Some days ago my son asked me how computer games are made. I couldn’t really explain it very well in terms he understood (he’s 5 years old), but I wanted to show it to him. Thus I started working with him on a 2D space shooter written in JavaScript, using the canvas element of HTML5. The result is playable at http://manuel.kiessling.net/projectile/.    The project source code is hosted at https://github.</description>
    </item>
    
    <item>
      <title>Project: bivouac, an HTML5 web chat with filesharing</title>
      <link>https://manuel.kiessling.net/2012/03/18/project-bivouac-an-html5-web-chat-with-filesharing/</link>
      <pubDate>Sun, 18 Mar 2012 16:13:00 +0100</pubDate>
      
      <guid>https://manuel.kiessling.net/2012/03/18/project-bivouac-an-html5-web-chat-with-filesharing/</guid>
      <description>Some weeks ago I started working on a new open source software, called bivouac.  bivouac provides an open source software package which allows to easily setup and run web-based group chats with dead-simple file-sharing (drag a file into the chat, and it’s immediately available as a download for all chat members).   Besides these “feature goals”, my secondary goal is to learn how to architect JavaScript applications that are relatively complex, with domain-driven design and a strong separation of concerns in mind.</description>
    </item>
    
    <item>
      <title>Interview on the Leanpub Podcast</title>
      <link>https://manuel.kiessling.net/2012/03/17/interview-on-the-leanpub-podcast/</link>
      <pubDate>Sat, 17 Mar 2012 16:13:00 +0100</pubDate>
      
      <guid>https://manuel.kiessling.net/2012/03/17/interview-on-the-leanpub-podcast/</guid>
      <description>Peter Armstrong from Leanpub, where I publish my eBooks, did an interview with me on the experience of releasing The Node Beginner Book on their platform, how bundling books work out, pricing, on learning from each other in the Internet age, and much more.  My English is awful as always and the transcript has some funny flaws, but if you like, check out the audio version or the text version below:  Peter Armstrong I’m here with Manuel Kiessling, who’s a software developer and IT manager living in Berlin, Germany.</description>
    </item>
    
    <item>
      <title>Deploying Symfony2 Apps via Scalarium: Improved Methodology</title>
      <link>https://manuel.kiessling.net/2012/01/05/deploying-symfony2-apps-via-scalarium-improved-methodology/</link>
      <pubDate>Thu, 05 Jan 2012 16:13:00 +0100</pubDate>
      
      <guid>https://manuel.kiessling.net/2012/01/05/deploying-symfony2-apps-via-scalarium-improved-methodology/</guid>
      <description>Some weeks ago I wrote about deploying Symfony2 Applications to Amazon AWS with Scalarium. It turned out that the described methodology can be improved in several ways. Here’s how.  First, let’s discuss what’s suboptimal with the previously described approach. The basic idea was to provide a custom Chef recipe which is executed on our instances whenever our Symfony2 application gets deployed. This recipe took care of   executing the tasks which need to be done whenever the application is deployed, like installing the Symfony2 vendors or cleaning the application cache   configuring Apache to correctly serve the application</description>
    </item>
    
    <item>
      <title>Cocoa: What to do if outlineView: objectValue ForTableColumn: byItem never gets called</title>
      <link>https://manuel.kiessling.net/2011/11/15/what-to-do-if-outlineview-objectvaluefortablecolumn-byitem-is-never-called/</link>
      <pubDate>Tue, 15 Nov 2011 16:13:00 +0100</pubDate>
      
      <guid>https://manuel.kiessling.net/2011/11/15/what-to-do-if-outlineview-objectvaluefortablecolumn-byitem-is-never-called/</guid>
      <description>If you set up an OutlineView in Interface Builder and connect your Controller as its dataSource and delegate (and provide the methods there accordingly), you will notice that  - (id)outlineView:(NSOutlineView *)outlineView objectValueForTableColumn:(NSTableColumn *)tableColumn byItem:(id)item  never get’s called. The reason might very simple: in Interface Builder, in the attributes inspector for your OutlineView, you can define the Content Mode as View Based or Cell Based.  If you simply want to display the content of NSStrings, choose Cell Based, and objectValueForTableColumn will be called.</description>
    </item>
    
    <item>
      <title>How hosting MyHammer started in a devops way back in the day</title>
      <link>https://manuel.kiessling.net/2011/11/07/how-hosting-myhammer-started-in-a-devops-way-back-in-the-day/</link>
      <pubDate>Mon, 07 Nov 2011 16:13:00 +0100</pubDate>
      
      <guid>https://manuel.kiessling.net/2011/11/07/how-hosting-myhammer-started-in-a-devops-way-back-in-the-day/</guid>
      <description>This here is just me, bragging about myself. You have been warned.    This guy with the psychopathic look standing in a room full of rubbish in front of something that vaguely looks like computers is me standing in front of the first MyHammer server cluster, only days before the whole system went into production.  It was 2005, and I had set up the whole system in a way I’m still quite proud of.</description>
    </item>
    
    <item>
      <title>Deploying Symfony2 Applications to Amazon AWS with Scalarium</title>
      <link>https://manuel.kiessling.net/2011/11/01/deploying-symfony2-applications-to-amazon-aws-with-scalarium/</link>
      <pubDate>Tue, 01 Nov 2011 16:13:00 +0100</pubDate>
      
      <guid>https://manuel.kiessling.net/2011/11/01/deploying-symfony2-applications-to-amazon-aws-with-scalarium/</guid>
      <description>Important Note  The methodology explained here is outdated, please read Deploying Symfony2 Apps via Scalarium: Improved Methodology for an updated version. About  This article describes how to use the cloud-based cluster-management platform Scalarium in order to automatically mass-deploy Symfony2 applications with a MySQL database backend onto clusters of Amazon EC2 virtual machines by creating a special Symfony2 environment, using a custom Chef recipe, and making use of Doctrine migrations.</description>
    </item>
    
    <item>
      <title>Behaviour-driven node.js development with stubbing by combining Vows and node-gently</title>
      <link>https://manuel.kiessling.net/2011/04/13/behaviour-driven-node-js-development-with-stubbing-by-combining-vows-and-node-gently/</link>
      <pubDate>Wed, 13 Apr 2011 16:13:00 +0100</pubDate>
      
      <guid>https://manuel.kiessling.net/2011/04/13/behaviour-driven-node-js-development-with-stubbing-by-combining-vows-and-node-gently/</guid>
      <description>I’m about 3.5 hours into node.js development, I guess that qualifies me to give advice on it on this Internet thing.  Being the BDD fanatic that I am, I wanted to start off behaviour-driven right from the beginning, and Vows looked like a good choice.  However, I quickly came to the point where I needed to stub out a dependency in one of my modules, and as far as I can see, Vows doesn’t provide mocking/stubbing.</description>
    </item>
    
    <item>
      <title>The only job application form that makes sense</title>
      <link>https://manuel.kiessling.net/2011/04/11/the-only-job-application-form-that-makes-sense/</link>
      <pubDate>Wed, 13 Apr 2011 16:13:00 +0100</pubDate>
      
      <guid>https://manuel.kiessling.net/2011/04/11/the-only-job-application-form-that-makes-sense/</guid>
      <description> It just dawned on me that this is really the only job application form that makes sense, isn’t it?  </description>
    </item>
    
    <item>
      <title>Why developing without tests is like driving a car without brakes</title>
      <link>https://manuel.kiessling.net/2011/04/07/why-developing-without-tests-is-like-driving-a-car-without-brakes-2/</link>
      <pubDate>Thu, 07 Apr 2011 16:13:00 +0100</pubDate>
      
      <guid>https://manuel.kiessling.net/2011/04/07/why-developing-without-tests-is-like-driving-a-car-without-brakes-2/</guid>
      <description>The following roots in something I heard from Jon Jagger at QCon London 2011 after his fantastic talk about Deliberate Practice. It was related to Test Driven Development. He asked “Why do cars have brakes?”. It made us think “To stop!”, but he said “No – to go faster”.  (Jon points out he didn’t invent it, he heard it from Kevlin Henney).  I have been thinking about this ever since, and here is what I came up with.</description>
    </item>
    
    <item>
      <title>Visualization: Why working iterative works</title>
      <link>https://manuel.kiessling.net/2011/03/10/visualization-why-working-iterative-works/</link>
      <pubDate>Thu, 10 Mar 2011 16:13:00 +0100</pubDate>
      
      <guid>https://manuel.kiessling.net/2011/03/10/visualization-why-working-iterative-works/</guid>
      <description>I’m really into visualizations. More often than not I can only really “get” something (a complex system, an abstract idea, a process etc.) when I see it visualized. You could call this the transformation of gut feelings into images.  So, I had this (rather obvious) gut feeling that working iterative in software projects makes a lot of sense, I’ve heard all the arguments and explanations and examples and stuff like that, and I probably already “got it”, but I thought it could make sense to clearly work out why exactly it makes sense, by visualizing it.</description>
    </item>
    
    <item>
      <title>Interview mit mir auf dem O’Reilly Blog</title>
      <link>https://manuel.kiessling.net/2011/01/31/interview-mit-mir-auf-dem-oreilly-blog/</link>
      <pubDate>Mon, 31 Jan 2011 16:13:00 +0100</pubDate>
      
      <guid>https://manuel.kiessling.net/2011/01/31/interview-mit-mir-auf-dem-oreilly-blog/</guid>
      <description>Das Blog von O’Reilly Deutschland hat in seiner Reihe “Karriere(n) in der IT” ein kurzes Interview mit mir geführt:  https://blog.oreilly.de/2011/01/31/job-portrait-softwarenentwickler-bei-myhammer-de/  Zum Zwecke der Archivierung drucke ich das Interview im Folgenden auch hier ab:   In der Reihe „Karriere(n) in der IT“ stellen wir Ihnen heute Manuel Kießling vor, der die Softwareentwicklung des Handwerks- und Dienstleistungsmarktplatzes MyHammer.de verantwortet. Sein Aufruf an den IT-Nachwuchs lautet: „Die eigene Komfortzone verlassen!</description>
    </item>
    
    <item>
      <title>Empfehlung: Literatur für Manager</title>
      <link>https://manuel.kiessling.net/2011/01/21/literatur-fuer-manager/</link>
      <pubDate>Fri, 21 Jan 2011 16:13:00 +0100</pubDate>
      
      <guid>https://manuel.kiessling.net/2011/01/21/literatur-fuer-manager/</guid>
      <description>Ich werde oft gefragt, wie ich so ein hervorragender Manager geworden bin. Haha, quatsch, kein Mensch fragt mich das. Ich stelle mir nur manchmal vor, dass es so wäre. Dann weine ich mich langsam in den Schlaf… Wo war ich? Ach ja.  Also, ich wurde nach Literatur zum Thema Management bzw. Mitarbeiterführung gefragt. Spontan fiel mir dazu erst mal nicht viel ein, weil ich keinen Kanon dazu im Hinterkopf habe, und weil Führungsqualitäten sowieso nur bedingt anlesbar sind.</description>
    </item>
    
    <item>
      <title>Neues Projekt: Platform Health Viewer</title>
      <link>https://manuel.kiessling.net/2011/01/11/neues-projekt-platform-health-viewer/</link>
      <pubDate>Tue, 11 Jan 2011 16:13:00 +0100</pubDate>
      
      <guid>https://manuel.kiessling.net/2011/01/11/neues-projekt-platform-health-viewer/</guid>
      <description>Platform Health Viewer (kurz PHV) ist mein aktuelles Ruby on Rails Hobbyprojekt.  Sobald es einen stabilen Zustand erreicht, wird dieses Tool das Sammeln und Visualisieren verschiedener statistischer Daten, wie sie typischerweise von Internetplattformen erzeugt werden, schnell und leichtgewichtig ermöglichen. Beispiele für diese Daten sind Dinge wie die CPU Last einzelner Systeme, Benutzerlogins, Anzahl der Seitenaufrufe usw.  Die Applikation basiert in erster Linie auf Rails, der HTTP Server für die Datenanlieferung ist in node.</description>
    </item>
    
    <item>
      <title>New project: Platform Health Viewer</title>
      <link>https://manuel.kiessling.net/2011/01/11/platform-health-viewer/</link>
      <pubDate>Tue, 11 Jan 2011 16:13:00 +0100</pubDate>
      
      <guid>https://manuel.kiessling.net/2011/01/11/platform-health-viewer/</guid>
      <description>Platform Health Viewer is my current Ruby on Rails pet project.  Once stable, it will allow users to easily collect and visualize different types of statistical data which is typically produced by internet platforms, like CPU performance, user logins, HTTP requests etc.  The main application is build on Rails, the server used for data collection is written in node.js, the web interface makes heavy use of jQuery and uses Raphaël to create SVG graphs.</description>
    </item>
    
    <item>
      <title>Testgetriebene Administration – test driven administration</title>
      <link>https://manuel.kiessling.net/2010/09/01/testgetriebene-administration-test-driven-administration/</link>
      <pubDate>Wed, 01 Sep 2010 16:13:00 +0100</pubDate>
      
      <guid>https://manuel.kiessling.net/2010/09/01/testgetriebene-administration-test-driven-administration/</guid>
      <description>Ich hatte tatsächlich einmal eine ganz eigene Idee. Und sie war gut, auch nachdem ich sie mehrmals durchgekaut und von allen Seiten beleuchtet hatte.  Wieso eigentlich sollte man die Prinzipien und Methodiken von testgetriebener Softwareentwicklung nicht auch auf den Bereich der IT-Systemadministration übertragen? Also in aller Kürze: Ich definiere Tests, die das vom noch zu implementierenden System erwartete Verhalten prüfen, sehe zu wie diese Tests fehlschlagen, und erfülle dann schrittweise diese Tests, indem ich das System aufbaue.</description>
    </item>
    
    <item>
      <title>&lt;angular/&gt; – ein radikal neuer Weg, Ajax Applikationen zu schreiben</title>
      <link>https://manuel.kiessling.net/2010/08/25/angular-ein-radikal-neuer-weg-ajax-applikationen-zu-schreiben/</link>
      <pubDate>Wed, 25 Aug 2010 16:13:00 +0100</pubDate>
      
      <guid>https://manuel.kiessling.net/2010/08/25/angular-ein-radikal-neuer-weg-ajax-applikationen-zu-schreiben/</guid>
      <description>JavaScript, Ajax und DHTML sind nicht wirklich meine Welt. Zum einen, weil ich einfach grundsätzlich eher mit dem Backend einer Software als mit dem Frontend zu tun habe, zum anderen, weil ich immer schon das ungute Gefühl hatte, in diesem Bereich muss man einfach deutlich zu viel Code produzieren um damit dann gefühlt deutlich zu wenig zu erreichen.  Umso mehr hat &amp;lt;angular/&amp;gt; mein Interesse geweckt. Die Autoren versprechen: Write less code.</description>
    </item>
    
    <item>
      <title>Tutorial: Testgetriebene Entwicklung mit PHP</title>
      <link>https://manuel.kiessling.net/2010/08/23/tutorial-testgetriebene-entwicklung-mit-php/</link>
      <pubDate>Mon, 23 Aug 2010 16:13:00 +0100</pubDate>
      
      <guid>https://manuel.kiessling.net/2010/08/23/tutorial-testgetriebene-entwicklung-mit-php/</guid>
      <description>Einleitung  Testgetriebene Entwicklung (test driven development) ist eine Arbeitsmethodik, die Softwareentwickler dabei unterstützt, wichtige Qualitätsprinzipien bei der Erstellung von Code zu befolgen: 

  Lose Kopplung (loose couping) – weil man beim Schreiben von Unittests, dem zentralen Werkzeug der Methodik, ganz automatisch dazu verführt wird, innerhalb der Tests von Codeunits (Klassen, Methoden usw.) auszugehen, die möglichst wenige Abhängigkeiten zu anderen Modulen haben – einfach deshalb, weil das Schreiben der Tests dann zu nervig wird.</description>
    </item>
    
    <item>
      <title>Empfehlung: Barbecue Sauce “Bone Suckin’ regular thicker style” von Ford’s Food</title>
      <link>https://manuel.kiessling.net/2010/07/13/empfehlung-barbeque-soss-bone-suckin-sauce-regular/</link>
      <pubDate>Tue, 13 Jul 2010 16:13:00 +0100</pubDate>
      
      <guid>https://manuel.kiessling.net/2010/07/13/empfehlung-barbeque-soss-bone-suckin-sauce-regular/</guid>
      <description>Klar, über Geschmack lässt sich immer streiten, aber über den Geschmack von Barbecue Saucen wahrscheinlich am meisten.  Die beste Sauce, die zu probieren ich bisher das Vergnügen hatte, ist jedenfalls völlig zweifelsfrei die “Bone Suckin’ Sauce regular” von Ford’s Food.  Phil Ford war Immobilienmakler und hat aus einem Hobby heraus angefangen, diese Sauce zu entwickeln. Sie hat nur wenig Raucharoma und ist nicht scharf, im Vordergrund steht vor allem ein fantastisches Tomatenaroma und eine gewisse Süße, die es aber auch nicht übertreibt.</description>
    </item>
    
    <item>
      <title>Empfehlung: “Der Kuchenladen” in Berlin</title>
      <link>https://manuel.kiessling.net/2010/07/13/empfehlung-der-kuchenladen-in-berlin/</link>
      <pubDate>Tue, 13 Jul 2010 16:13:00 +0100</pubDate>
      
      <guid>https://manuel.kiessling.net/2010/07/13/empfehlung-der-kuchenladen-in-berlin/</guid>
      <description>Die Konditorei “Der Kuchenladen” ist sogar die nervige Parkplatzsuche auf der Kantstraße wert. Handgemachte Torten, Kuchen und Tarts, die klasse aussehen und einfach gut schmecken.  Das Wichtigste: Auf übertriebene effekthascherische Zuckerguß-Ungetüme wird verzichtet – die Torten zeichnet neben der spürbaren handwerklichen Qualität vor allem aus, dass sie nicht zu süß sind.  Als Schwiegersohn einer Konditoreimeisterin bin ich sehr verwöhnt, aber der Kuchenladen hat mich noch nie enttäuscht.   Der Kuchenladen</description>
    </item>
    
    <item>
      <title>Project: PHPRestfulSubversion</title>
      <link>https://manuel.kiessling.net/2010/05/21/project-phprestfulsubversion/</link>
      <pubDate>Fri, 21 May 2010 16:13:00 +0100</pubDate>
      
      <guid>https://manuel.kiessling.net/2010/05/21/project-phprestfulsubversion/</guid>
      <description>PHPRestfulSubversion…  …provides a RESTful JSON webservice API to access information in your Subversion repository, …provides tools to cache your Subversion repository in order to make it searchable through the webservice in a fast and simple manner, …is a library of PHP classes which you can use to implement more complex use cases.  
 A secondary goal of this project is to explore how to create very clean PHP code using a 100% test-driven approach.</description>
    </item>
    
    <item>
      <title>Alte Homepage wieder verfügbar</title>
      <link>https://manuel.kiessling.net/2010/04/30/alte-homepage-wieder-verfugbar/</link>
      <pubDate>Fri, 30 Apr 2010 16:13:00 +0100</pubDate>
      
      <guid>https://manuel.kiessling.net/2010/04/30/alte-homepage-wieder-verfugbar/</guid>
      <description>Meine alte Homepage (2000-2005) ist wiederauferstanden und unter http://old.manuel.kiessling.net/ erreichbar.</description>
    </item>
    
    <item>
      <title>siqqel: SQL-Abfragen direkt aus HTML heraus ausführen und darstellen</title>
      <link>https://manuel.kiessling.net/2010/04/08/siqqel-ein-sehr-nutzliches-tool-fur-entwickler-business-analysten-produktmanager-und-qaler/</link>
      <pubDate>Thu, 08 Apr 2010 16:13:00 +0100</pubDate>
      
      <guid>https://manuel.kiessling.net/2010/04/08/siqqel-ein-sehr-nutzliches-tool-fur-entwickler-business-analysten-produktmanager-und-qaler/</guid>
      <description>Ein Kollege von mir, Max Winde, hat in den vergangenen Wochen ein Tool geschrieben welches sich innerhalb kürzester Zeit zu einem Renner in den verschiedensten Abteilungen entwickelt hat, und schon jetzt aus dem Arbeitsalltag kaum noch wegzudenken ist: siqqel.  Welchen Zweck erfüllt siqqel?  Die verschiedensten Leute in einem Unternehmen müssen aus den verschiedensten Gründen auf relationale Datenbanken zugreifen. Klassischerweise gibt es zwei Szenarien:   Ich brauche eine einfache und kurze Information Beispiel: “Wie war noch gleich der ‘name’ des ‘product’ mit der Id 12345?</description>
    </item>
    
    <item>
      <title>Database Change Management mithilfe von VCS: Teil 1</title>
      <link>https://manuel.kiessling.net/2010/02/26/database-change-management-mithilfe-von-vcs-teil-1/</link>
      <pubDate>Fri, 26 Feb 2010 16:13:00 +0100</pubDate>
      
      <guid>https://manuel.kiessling.net/2010/02/26/database-change-management-mithilfe-von-vcs-teil-1/</guid>
      <description>Dieser Artikel ist Work in Progress!
Vorüberlegungen Dieses Dokument beschreibt Werkzeuge und Prozesse, um Datenbankänderungen innerhalb von großen Softwareprojekten einfach, fehlerfrei und nachvollziehbar durchzuführen und zu managen.
Zentraler Ansatz dieser Lösung ist: Datenbankänderungen und Codeänderungen sind prinzipiell genau dasselbe. Denn Datenbankänderungen haben genau wie Codeänderung die folgenden Eigenschaften:
 Sie ändern das Verhalten des Softwaresystems Sie entwickeln sich verteilt in verschiedenen Projekten bzw. Branches, und müssen für Abnahme und Rollout/Release zusammengeführt werden Beim Zusammenführen kann es Überschneidungen und Konflikte geben, die man mitbekommen und lösen können möchte Man möchte sie auch später noch nachvollziehen können, also sehen wer wann was gemacht hat Man möchte diese Änderungen ggf.</description>
    </item>
    
    <item>
      <title>Wie man Replikationsunterbrechung durch Deadlocks bei INSERT INTO … SELECT verhindert</title>
      <link>https://manuel.kiessling.net/2007/08/07/wie-man-replikationsunterbrechung-durch-deadlocks-bei-insert-into-select-verhindert/</link>
      <pubDate>Tue, 07 Aug 2007 16:13:00 +0100</pubDate>
      
      <guid>https://manuel.kiessling.net/2007/08/07/wie-man-replikationsunterbrechung-durch-deadlocks-bei-insert-into-select-verhindert/</guid>
      <description>Der My-Hammer Auftragsradar, der unsere Auftragnehmer auf Wunsch regelmässig per E-Mail über neu eingestellte Auktionen anhand einstellbarer Filterkriterien informiert, baut bei jedem Durchlauf eine eigene Suchtabelle auf. Diese wird gefüllt mit einer Untermenge der Daten unserer Haupt-Auktionstabelle, nämlich nur den derzeit laufenden Auktionen.
Die Verwendung von INSERT INTO … SELECT ist hier naheliegend, zum Beispiel so:
INSERT INTO Suchtabelle &amp;nbsp;SELECT a, b, c FROM Auktionstabelle WHERE x = y</description>
    </item>
    
    <item>
      <title>Recycelter Artikel: “My-Hammer, das Fernsehen und die Serverlast”</title>
      <link>https://manuel.kiessling.net/2007/07/17/recycelter-artikel-my-hammer-das-fernsehen-und-die-serverlast/</link>
      <pubDate>Tue, 17 Jul 2007 16:13:00 +0100</pubDate>
      
      <guid>https://manuel.kiessling.net/2007/07/17/recycelter-artikel-my-hammer-das-fernsehen-und-die-serverlast/</guid>
      <description>Vor mittlerweile auch schon wieder einer halben Ewigkeit hatte ich mal eine kurze Artikelserie zum Thema Serverlast-Problemlösungen bei MyHammer online, die ich nun wieder ausgegraben habe. Vieles entspricht gar nicht mehr den aktuell bei MyHammer eingesetzten Lösungen, aber verwahrenswert finde ich den Schrieb allemal. Leider fehlen die Grafiken, vielleicht finde ich die noch mal irgendwo.  Hier der Artikel:  Vergangenen Donnerstag zeigte das ProSieben Magazin Galileo einen ca. 10-minütigen Beitrag über My-Hammer (kurze Infos zur Sendung hier).</description>
    </item>
    
  </channel>
</rss>