{"id":1002,"date":"2019-10-28T18:41:46","date_gmt":"2019-10-28T17:41:46","guid":{"rendered":"http:\/\/blog.zhaw.ch\/splab\/?p=1002"},"modified":"2019-10-29T12:05:18","modified_gmt":"2019-10-29T11:05:18","slug":"reflections-on-teaching-serverless-and-cloud-native-application-development","status":"publish","type":"post","link":"https:\/\/blog.zhaw.ch\/splab\/2019\/10\/28\/reflections-on-teaching-serverless-and-cloud-native-application-development\/","title":{"rendered":"Reflections on Teaching Serverless and Cloud-native Application Development"},"content":{"rendered":"\n<p>With the proliferation of hybrid cloud, cross-cloud and post-cloud environments, finding the right concepts and tools to produce mixed-technology applications and services remains challenging. At Zurich University of Applied Sciences, a course on <em>Serverless and Cloud-native Application Development (SCAD)<\/em> prepares bachelor students in computer science for facing these challenges. We argue that this is the first such lecture in Switzerland and probably even in the world. Three years after <a href=\"https:\/\/blog.zhaw.ch\/icclab\/reflections-on-teaching-internet-service-prototyping\/\">reflecting<\/a> on Internet Service Prototyping teaching, this mid-semester blog post sums up the evolution of the field, explains the course design of SCAD and briefly reports on the lab results.<\/p>\n\n\n\n<figure class=\"wp-block-image\"><img loading=\"lazy\" decoding=\"async\" width=\"600\" height=\"482\" src=\"https:\/\/blog.zhaw.ch\/splab\/files\/2019\/10\/scadbg.jpg\" alt=\"\" class=\"wp-image-1038\" srcset=\"https:\/\/blog.zhaw.ch\/splab\/files\/2019\/10\/scadbg.jpg 600w, https:\/\/blog.zhaw.ch\/splab\/files\/2019\/10\/scadbg-300x241.jpg 300w\" sizes=\"auto, (max-width: 600px) 100vw, 600px\" \/><\/figure>\n\n\n\n<!--more-->\n\n\n\n<p><strong>Course Context<\/strong><\/p>\n\n\n\n<p>Going cloud-native is an ongoing trend for businesses around the world. Marked with <a href=\"https:\/\/events19.linuxfoundation.org\/events\/kubecon-cloudnativecon-europe-2020\/\">big conferences<\/a> and smaller events, the question for application developers boils down to: How do I design, implement, compose, test and deploy the application in a way that it optimally executes under the given plethora of hosting models in clouds and future post-cloud systems? How do I cope with the service orientation inherently required for discoverable and re-usable event-driven functionality? How do I ensure that platform capabilities around elastic scalability, true pay-per-use billing, low latency invocation, microservice lifecycle management and differentiated storage are fully exploited in my software structure?<\/p>\n\n\n\n<p>This course enables bachelor students to seek appropriate answers to these questions from an application developer perspective by walking them through the topics and supplying them with various cloud resources which can be combined so that multi-cloud and cross-cloud applications emerge. The evolution of technological capabilities requires trade-offs with simplicity which are hard to be conveyed on slides alone. Through practical lab sessions, they are experienced first-hand.<\/p>\n\n\n\n<p>It is inspiring to see how technological progress allows for turning theoretic topics into action. A few years ago, teaching on workflows in service-oriented systems was mostly confined to BPEL, a heavy-weight service orchestration approach which never really made it into practice beyond few selected enterprise systems. Nowadays, composing cloud functions into serverless workflows is relatively easy and something students can try out within minutes. Other topics, such as <a href=\"http:\/\/www.arxitics.com\/articles\/1905.04800\">microservice artefact quality analysis<\/a>, remain research-centric but may also become standard tooling in a few years. Thus, the <a href=\"https:\/\/blog.zhaw.ch\/splab\/for-students\/\">Service Prototyping Lab<\/a> at Zurich University of Applied Sciences remains committed to transfer research results into practice and into education.<\/p>\n\n\n\n<p><strong>Course Structure<\/strong><\/p>\n\n\n\n<p><em>Week 1: Mastering Clouds.<\/em> In the first week, our students learn about various paths into the digital world, in particular into mixed-technology cloud platforms. In between computing paradigms and a brief introduction into service orientation along with service ecosystems, students better understand the fuzzy positioning of cloud-native, serverless and FaaS.<\/p>\n\n\n\n<figure class=\"wp-block-image\"><img loading=\"lazy\" decoding=\"async\" width=\"712\" height=\"676\" src=\"http:\/\/blog.zhaw.ch\/splab\/files\/2019\/10\/scadscape.png\" alt=\"\" class=\"wp-image-1026\" srcset=\"https:\/\/blog.zhaw.ch\/splab\/files\/2019\/10\/scadscape.png 712w, https:\/\/blog.zhaw.ch\/splab\/files\/2019\/10\/scadscape-300x285.png 300w, https:\/\/blog.zhaw.ch\/splab\/files\/2019\/10\/scadscape-676x642.png 676w, https:\/\/blog.zhaw.ch\/splab\/files\/2019\/10\/scadscape-24x24.png 24w\" sizes=\"auto, (max-width: 712px) 100vw, 712px\" \/><\/figure>\n\n\n\n<p>In the hands-on lab part, they dive deeper into the FaaS world and experimentally observe the behaviour of commercial FaaS runtimes, including memory and duration limits, cold starts and the influence of function code size and memory allocation.<\/p>\n\n\n\n<figure class=\"wp-block-image\"><img loading=\"lazy\" decoding=\"async\" width=\"603\" height=\"361\" src=\"https:\/\/blog.zhaw.ch\/splab\/files\/2019\/10\/res5.png\" alt=\"\" class=\"wp-image-1036\" srcset=\"https:\/\/blog.zhaw.ch\/splab\/files\/2019\/10\/res5.png 603w, https:\/\/blog.zhaw.ch\/splab\/files\/2019\/10\/res5-300x180.png 300w\" sizes=\"auto, (max-width: 603px) 100vw, 603px\" \/><figcaption>Investigated by students P. Weber &amp; M. Jung: &#8216;There seems to be a warmup effect. The function call is slightly faster on repeated calls and speeds up markedly once the interval gets down to 10s. There is one outlier midway through the data. The slowdown at the very end is due to sending \/ recieving multiple requests in a matter of milliseconds.&#8217;<\/figcaption><\/figure>\n\n\n\n<p><em>Week 2: Serverless Applications.<\/em> Students learn about serverless computing paradigms, FaaS and BaaS combinations, cloud functions as non-standardised programming\/packaging\/deployment\/execution models, and higher-layer application models such as SAM. Beyond technical aspects, the distinct lack of a Swiss\/European-based commercial offering is discussed. This fits our strategy as we do not only help local companies with <a href=\"https:\/\/blog.zhaw.ch\/splab\/for-companies\/\">science-based innovation<\/a> directly, but also indirectly with the supply of technically capable alumni.<\/p>\n\n\n\n<figure class=\"wp-block-image\"><img loading=\"lazy\" decoding=\"async\" width=\"1024\" height=\"380\" src=\"https:\/\/blog.zhaw.ch\/splab\/files\/2019\/10\/faasification-1024x380.png\" alt=\"\" class=\"wp-image-1028\" srcset=\"https:\/\/blog.zhaw.ch\/splab\/files\/2019\/10\/faasification-1024x380.png 1024w, https:\/\/blog.zhaw.ch\/splab\/files\/2019\/10\/faasification-300x111.png 300w, https:\/\/blog.zhaw.ch\/splab\/files\/2019\/10\/faasification-768x285.png 768w, https:\/\/blog.zhaw.ch\/splab\/files\/2019\/10\/faasification-676x251.png 676w, https:\/\/blog.zhaw.ch\/splab\/files\/2019\/10\/faasification.png 1401w\" sizes=\"auto, (max-width: 1024px) 100vw, 1024px\" \/><\/figure>\n\n\n\n<p><em>Week 3: Serverless Development.<\/em> After an overview about development processes and tools, the first major focus is on FaaSification tooling and related overlay techniques such as PyWren and Gee&#8217;s Lambada. Function tainting and monads are introduced as important concepts for function calling other functions. Deployment frameworks, mock tools and debugging approaches are also presented in this context. In the hands-on lab, students develop simple cloud functions as web actions with database connection to persist form contents.<\/p>\n\n\n\n<figure class=\"wp-block-image\"><img loading=\"lazy\" decoding=\"async\" width=\"660\" height=\"481\" src=\"https:\/\/blog.zhaw.ch\/splab\/files\/2019\/10\/termite.png\" alt=\"\" class=\"wp-image-1031\" srcset=\"https:\/\/blog.zhaw.ch\/splab\/files\/2019\/10\/termite.png 660w, https:\/\/blog.zhaw.ch\/splab\/files\/2019\/10\/termite-300x219.png 300w\" sizes=\"auto, (max-width: 660px) 100vw, 660px\" \/><\/figure>\n\n\n\n<p><em>Week 4: Serverless Workflows.<\/em> Different workflow concepts, systems and languages are presented, ranging from conventional workflows like Montage, and their adaptations to serverless environments, to new approaches like Step Functions, IBM Composer and Fission Workflows. The performance characteristics including interference of cold starts, instance pool exhaustion and instance migration between VMs are elaborated on along with the overhead, but also the potential advantages, of using workflow managers. The optimisation of workflow execution with techniques such as <a href=\"http:\/\/essca2018.servicelaboratory.ch\/slides\/essca18-slides-erwinvaneyk-scaled.pdf\">horizon-based pre-warming<\/a> is discussed. A TODO manager application is presented as in-depth scenario. In the practical lab, students write their own mini-workflow manager which can handle sequences of functions chained together, and experience the characteristics of running the manager as a function itself.<\/p>\n\n\n\n<pre class=\"wp-block-preformatted\">{     \n  \"result\": {\n    \"name\": \"[workflow] ~ Workflow manager || F1 || F2\",\n    \"message\": \"[okey] ~ Started workflow manager || Call F1 || Call F2\"\n  },\n  \"statistics\": [\n    {\n      \"name\": \"f1\",\n      \"result\": 2024\n    },\n    {\n      \"name\": \"f2\",\n      \"result\": 2024\n    },\n    {\n      \"name\": \"Workflow manager\",\n      \"result\": 4049\n    }\n  ]\n}<\/pre>\n\n\n\n<p class=\"has-text-color has-background has-small-font-size has-medium-gray-color has-white-background-color\"><em>Investigated by students L. Germann, M. Goetschi and A. Parenti: &#8216;We see that with the prewarm flag set to true, we get almost identical speed measures. A possible explanation for that behavior is that we call the functions all the time, even if prewarm is set to true\u2026&#8217;<\/em><\/p>\n\n\n\n<p><em>Week 5: Serverless Use Cases.<\/em> Computer science boredom, begone! After having seen all the theoretic concepts to build serverless applications, students experience actual business use cases, many of them with a regional context. Examples are given for <a href=\"https:\/\/www.homegate.ch\/de\">Homegate<\/a>&#8216;s cloud function workflows for real estate listings and in detail for <a href=\"https:\/\/locize.com\/\">Locize<\/a>&#8216;s application architecture, apart from the <a href=\"http:\/\/serverless.research-output.org\/\">scientifically scrutinised<\/a> chat bot, energy management and video encoding examples. File management and multi-cloud management with cloud functions are presented as well, relating to our <a href=\"https:\/\/blog.zhaw.ch\/splab\/2019\/05\/23\/serverless-plumbing-connecting-a-nextcloud-file-store-to-knative\/\">previous research<\/a> in conjunction with companies in Switzerland. In the lab part, students start building their first cloud function-based and FaaS-hosted application, fulfilling at least four out of seven requirements:<\/p>\n\n\n\n<ul class=\"wp-block-list\"><li>Using a deployment framework, like the Serverless Framework or Claudia.js (or just plain Terraform in one case)<\/li><li>Using a workflow manager, either a hosted commercial system or a self-hosted one.<\/li><li>Stateful processing with a message queue or database.<\/li><li>Inter-process communication with a long-running rendezvous server, inspired by the <a href=\"http:\/\/ex.camera\/nsdi17\/\">Ex.camera<\/a> design.<\/li><li>FaaSification with Lambada, Termite &amp; Co.<\/li><li>Self-optimisation by injecting calibration logic, such as processing tasks closer to the 100ms billing boundaries.<\/li><li>Content triggering from the backend services.<\/li><\/ul>\n\n\n\n<figure class=\"wp-block-image\"><img loading=\"lazy\" decoding=\"async\" width=\"1024\" height=\"576\" src=\"https:\/\/blog.zhaw.ch\/splab\/files\/2019\/10\/homegate-1024x576.png\" alt=\"\" class=\"wp-image-1040\" srcset=\"https:\/\/blog.zhaw.ch\/splab\/files\/2019\/10\/homegate.png 1024w, https:\/\/blog.zhaw.ch\/splab\/files\/2019\/10\/homegate-300x169.png 300w, https:\/\/blog.zhaw.ch\/splab\/files\/2019\/10\/homegate-768x432.png 768w, https:\/\/blog.zhaw.ch\/splab\/files\/2019\/10\/homegate-676x380.png 676w\" sizes=\"auto, (max-width: 1024px) 100vw, 1024px\" \/><\/figure>\n\n\n\n<p><em>Week 6: Serverless Patterns and Pitfalls.<\/em> Going back to the technical details after the broad use case presentations, the patterns, antipatterns and (not so intuitive) pitfalls are studied. Owing to the similarities with software design patterns, serverless patterns such as &#8216;data transformation&#8217; and &#8216;state machine&#8217; are names that are understood by the respective developer community and thus provide a common language, workspace, implementation and foundation. More complex patterns such as &#8216;event-condition-action&#8217;, &#8216;forward&#8217; and &#8216;retry&#8217; are important in this context as well, as evidenced by the need to introduce client-side (i.e. function-side) workarounds due to the <a href=\"https:\/\/2017.onward-conference.org\/details\/onward-2017-Onward-Papers\/5\/The-Serverless-Trilemma-Function-Composition-for-Serverless-Computing\">serverless trilemma<\/a> inherent to today&#8217;s FaaS systems. Antipatterns are more folklore-\/rule of thumb-based, but nevertheless their consideration contributes to proper serverless and cloud-native application designs.<\/p>\n\n\n\n<figure class=\"wp-block-image\"><img loading=\"lazy\" decoding=\"async\" width=\"1024\" height=\"278\" src=\"https:\/\/blog.zhaw.ch\/splab\/files\/2019\/10\/tiplatform-1024x278.png\" alt=\"\" class=\"wp-image-1041\" srcset=\"https:\/\/blog.zhaw.ch\/splab\/files\/2019\/10\/tiplatform-1024x278.png 1024w, https:\/\/blog.zhaw.ch\/splab\/files\/2019\/10\/tiplatform-300x81.png 300w, https:\/\/blog.zhaw.ch\/splab\/files\/2019\/10\/tiplatform-768x208.png 768w, https:\/\/blog.zhaw.ch\/splab\/files\/2019\/10\/tiplatform-676x183.png 676w, https:\/\/blog.zhaw.ch\/splab\/files\/2019\/10\/tiplatform.png 1540w\" sizes=\"auto, (max-width: 1024px) 100vw, 1024px\" \/><\/figure>\n\n\n\n<p><em>Week 7: Containerised Applications.<\/em> To complement short-running functions, there are multiple techniques to achieve long-running application delivery. PaaS is one option &#8211; similar to FaaS, developers submit their code and, especially in conjunction with GitOps, care less about how it is deployed and executed. As the number of supported programming languages, frameworks and protocols in FaaS\/PaaS is limited, CaaS is another, more flexible but also more effort-intensive option. Developers create and maintain instructions to build container images which contain complex application parts or even, when departing from the microservices style, complete applications. Students use the lab to create <a href=\"https:\/\/appuio.ch\/\">and deploy<\/a> their own container images and to complement their previously created application with a long-running component.<\/p>\n\n\n\n<p><em>Weeks 8-14 summary:<\/em> The second half of the semester is still ahead of us. The lectures generalise cloud function implementations and container images into implementation artefacts, cover their statically and dynamically assessable quality aspects, shed light on dependencies between microservices, look at scalability and quality aspects in general, and touch on messaging and coordination in multi-cloud environments.<\/p>\n\n\n\n<p><strong>Course Resources<\/strong><\/p>\n\n\n\n<p>To meet the requirements of future employment as engineers (and hopefully in some cases as future master students), access to ready-to-use cloud platforms is indispensable in this course. The access will vary from year to year, but will always consist of a mix of global cloud platforms and local offerings. This year, we provided accounts to the IBM Cloud, the Google Cloud and APPUiO. None of these offers require a credit card, which is another essential factor for studying and exploring. Platform resources are used until certain quotas are hit. Concerning user management, the IBM offer is great for self-management and dynamic addition of students (e.g. late arrivals until two weeks after the start, or thesis students). The Google and APPUiO offerings work on vouchers which are also easy to request.<\/p>\n\n\n\n<p>Additionally, student teams of two (sometimes three) use a university-provided Git service to maintain their code and configuration files. A closer connection between Git and the deployment is an area of potential improvement for the FaaS offerings, but also for some other cloud services, to reduce turnaround times and to avoid code inconsistencies. Documentation on advanced features such as web actions is also lacking; the corresponding tasks are still causing an unnecessarily high cognitive load with students. Nevertheless, the paths from idea to hosted application have been shortened a lot with contemporary cloud engineering approaches.<\/p>\n\n\n\n<p>Overall, the course contributes to a modern and attractive <a href=\"https:\/\/www.zhaw.ch\/en\/engineering\/study\/bachelors-degree-programmes\/computer-science\/\">computer science curriculum<\/a> at Zurich University of Applied Sciences and increases the long-term competitiveness of local industry with skilled engineers. Students and instructors have fun playing with cloud-native application technologies, some already established, others bleeding edge research output.<\/p>\n<div class=\"pt-sm\">Schlagw\u00f6rter: <a href=\"http:\/\/blog.zhaw.ch\/splab\/tag\/cloud-application\/\">cloud application<\/a>, <a href=\"http:\/\/blog.zhaw.ch\/splab\/tag\/cloud-native\/\">cloud-native<\/a>, <a href=\"http:\/\/blog.zhaw.ch\/splab\/tag\/faas\/\">faas<\/a>, <a href=\"http:\/\/blog.zhaw.ch\/splab\/tag\/microservices\/\">microservices<\/a>, <a href=\"http:\/\/blog.zhaw.ch\/splab\/tag\/public-cloud\/\">public cloud<\/a>, <a href=\"http:\/\/blog.zhaw.ch\/splab\/tag\/serverless\/\">serverless<\/a>, <a href=\"http:\/\/blog.zhaw.ch\/splab\/tag\/workflows\/\">workflows<\/a><br><\/div>","protected":false},"excerpt":{"rendered":"<p>With the proliferation of hybrid cloud, cross-cloud and post-cloud environments, finding the right concepts and tools to produce mixed-technology applications and services remains challenging. At Zurich University of Applied Sciences, a course on Serverless and Cloud-native Application Development (SCAD) prepares bachelor students in computer science for facing these challenges. We argue that this is the [&hellip;]<\/p>\n","protected":false},"author":203,"featured_media":0,"comment_status":"open","ping_status":"open","sticky":false,"template":"","format":"standard","meta":{"ngg_post_thumbnail":0,"footnotes":""},"categories":[11],"tags":[112,20,7,39,113,8,111],"features":[],"class_list":["post-1002","post","type-post","status-publish","format-standard","hentry","category-education","tag-cloud-application","tag-cloud-native","tag-faas","tag-microservices","tag-public-cloud","tag-serverless","tag-workflows"],"yoast_head":"<!-- This site is optimized with the Yoast SEO Premium plugin v27.2 (Yoast SEO v27.2) - https:\/\/yoast.com\/product\/yoast-seo-premium-wordpress\/ -->\n<title>Reflections on Teaching Serverless and Cloud-native Application Development - Service Prototyping Lab<\/title>\n<meta name=\"robots\" content=\"index, follow, max-snippet:-1, max-image-preview:large, max-video-preview:-1\" \/>\n<link rel=\"canonical\" href=\"https:\/\/blog.zhaw.ch\/splab\/2019\/10\/28\/reflections-on-teaching-serverless-and-cloud-native-application-development\/\" \/>\n<meta property=\"og:locale\" content=\"en_GB\" \/>\n<meta property=\"og:type\" content=\"article\" \/>\n<meta property=\"og:title\" content=\"Reflections on Teaching Serverless and Cloud-native Application Development\" \/>\n<meta property=\"og:description\" content=\"With the proliferation of hybrid cloud, cross-cloud and post-cloud environments, finding the right concepts and tools to produce mixed-technology applications and services remains challenging. At Zurich University of Applied Sciences, a course on Serverless and Cloud-native Application Development (SCAD) prepares bachelor students in computer science for facing these challenges. We argue that this is the [&hellip;]\" \/>\n<meta property=\"og:url\" content=\"https:\/\/blog.zhaw.ch\/splab\/2019\/10\/28\/reflections-on-teaching-serverless-and-cloud-native-application-development\/\" \/>\n<meta property=\"og:site_name\" content=\"Service Prototyping Lab\" \/>\n<meta property=\"article:published_time\" content=\"2019-10-28T17:41:46+00:00\" \/>\n<meta property=\"article:modified_time\" content=\"2019-10-29T11:05:18+00:00\" \/>\n<meta property=\"og:image\" content=\"https:\/\/blog.zhaw.ch\/splab\/files\/2019\/10\/scadbg.jpg\" \/>\n<meta name=\"author\" content=\"Josef Spillner\" \/>\n<meta name=\"twitter:card\" content=\"summary_large_image\" \/>\n<meta name=\"twitter:label1\" content=\"Written by\" \/>\n\t<meta name=\"twitter:data1\" content=\"Josef Spillner\" \/>\n\t<meta name=\"twitter:label2\" content=\"Estimated reading time\" \/>\n\t<meta name=\"twitter:data2\" content=\"8 minutes\" \/>\n<script type=\"application\/ld+json\" class=\"yoast-schema-graph\">{\"@context\":\"https:\/\/schema.org\",\"@graph\":[{\"@type\":\"Article\",\"@id\":\"https:\/\/blog.zhaw.ch\/splab\/2019\/10\/28\/reflections-on-teaching-serverless-and-cloud-native-application-development\/#article\",\"isPartOf\":{\"@id\":\"https:\/\/blog.zhaw.ch\/splab\/2019\/10\/28\/reflections-on-teaching-serverless-and-cloud-native-application-development\/\"},\"author\":{\"name\":\"Josef Spillner\",\"@id\":\"https:\/\/blog.zhaw.ch\/splab\/#\/schema\/person\/33a5227c6cc1fa3329279d33c3cc440e\"},\"headline\":\"Reflections on Teaching Serverless and Cloud-native Application Development\",\"datePublished\":\"2019-10-28T17:41:46+00:00\",\"dateModified\":\"2019-10-29T11:05:18+00:00\",\"mainEntityOfPage\":{\"@id\":\"https:\/\/blog.zhaw.ch\/splab\/2019\/10\/28\/reflections-on-teaching-serverless-and-cloud-native-application-development\/\"},\"wordCount\":1606,\"commentCount\":0,\"image\":{\"@id\":\"https:\/\/blog.zhaw.ch\/splab\/2019\/10\/28\/reflections-on-teaching-serverless-and-cloud-native-application-development\/#primaryimage\"},\"thumbnailUrl\":\"https:\/\/blog.zhaw.ch\/splab\/files\/2019\/10\/scadbg.jpg\",\"keywords\":[\"cloud application\",\"cloud-native\",\"faas\",\"microservices\",\"public cloud\",\"serverless\",\"workflows\"],\"articleSection\":[\"Education\"],\"inLanguage\":\"en-GB\",\"potentialAction\":[{\"@type\":\"CommentAction\",\"name\":\"Comment\",\"target\":[\"https:\/\/blog.zhaw.ch\/splab\/2019\/10\/28\/reflections-on-teaching-serverless-and-cloud-native-application-development\/#respond\"]}]},{\"@type\":\"WebPage\",\"@id\":\"https:\/\/blog.zhaw.ch\/splab\/2019\/10\/28\/reflections-on-teaching-serverless-and-cloud-native-application-development\/\",\"url\":\"https:\/\/blog.zhaw.ch\/splab\/2019\/10\/28\/reflections-on-teaching-serverless-and-cloud-native-application-development\/\",\"name\":\"Reflections on Teaching Serverless and Cloud-native Application Development - Service Prototyping Lab\",\"isPartOf\":{\"@id\":\"https:\/\/blog.zhaw.ch\/splab\/#website\"},\"primaryImageOfPage\":{\"@id\":\"https:\/\/blog.zhaw.ch\/splab\/2019\/10\/28\/reflections-on-teaching-serverless-and-cloud-native-application-development\/#primaryimage\"},\"image\":{\"@id\":\"https:\/\/blog.zhaw.ch\/splab\/2019\/10\/28\/reflections-on-teaching-serverless-and-cloud-native-application-development\/#primaryimage\"},\"thumbnailUrl\":\"https:\/\/blog.zhaw.ch\/splab\/files\/2019\/10\/scadbg.jpg\",\"datePublished\":\"2019-10-28T17:41:46+00:00\",\"dateModified\":\"2019-10-29T11:05:18+00:00\",\"author\":{\"@id\":\"https:\/\/blog.zhaw.ch\/splab\/#\/schema\/person\/33a5227c6cc1fa3329279d33c3cc440e\"},\"breadcrumb\":{\"@id\":\"https:\/\/blog.zhaw.ch\/splab\/2019\/10\/28\/reflections-on-teaching-serverless-and-cloud-native-application-development\/#breadcrumb\"},\"inLanguage\":\"en-GB\",\"potentialAction\":[{\"@type\":\"ReadAction\",\"target\":[\"https:\/\/blog.zhaw.ch\/splab\/2019\/10\/28\/reflections-on-teaching-serverless-and-cloud-native-application-development\/\"]}]},{\"@type\":\"ImageObject\",\"inLanguage\":\"en-GB\",\"@id\":\"https:\/\/blog.zhaw.ch\/splab\/2019\/10\/28\/reflections-on-teaching-serverless-and-cloud-native-application-development\/#primaryimage\",\"url\":\"https:\/\/blog.zhaw.ch\/splab\/files\/2019\/10\/scadbg.jpg\",\"contentUrl\":\"https:\/\/blog.zhaw.ch\/splab\/files\/2019\/10\/scadbg.jpg\"},{\"@type\":\"BreadcrumbList\",\"@id\":\"https:\/\/blog.zhaw.ch\/splab\/2019\/10\/28\/reflections-on-teaching-serverless-and-cloud-native-application-development\/#breadcrumb\",\"itemListElement\":[{\"@type\":\"ListItem\",\"position\":1,\"name\":\"Startseite\",\"item\":\"https:\/\/blog.zhaw.ch\/splab\/\"},{\"@type\":\"ListItem\",\"position\":2,\"name\":\"Reflections on Teaching Serverless and Cloud-native Application Development\"}]},{\"@type\":\"WebSite\",\"@id\":\"https:\/\/blog.zhaw.ch\/splab\/#website\",\"url\":\"https:\/\/blog.zhaw.ch\/splab\/\",\"name\":\"Service Prototyping Lab\",\"description\":\"A Blog of the ZHAW Zurich University of Applied Sciences\",\"potentialAction\":[{\"@type\":\"SearchAction\",\"target\":{\"@type\":\"EntryPoint\",\"urlTemplate\":\"https:\/\/blog.zhaw.ch\/splab\/?s={search_term_string}\"},\"query-input\":{\"@type\":\"PropertyValueSpecification\",\"valueRequired\":true,\"valueName\":\"search_term_string\"}}],\"inLanguage\":\"en-GB\"},{\"@type\":\"Person\",\"@id\":\"https:\/\/blog.zhaw.ch\/splab\/#\/schema\/person\/33a5227c6cc1fa3329279d33c3cc440e\",\"name\":\"Josef Spillner\",\"image\":{\"@type\":\"ImageObject\",\"inLanguage\":\"en-GB\",\"@id\":\"https:\/\/secure.gravatar.com\/avatar\/c57d7019e91373902c08eac230e003cb4f8498ecf68c9d119e9ecb82fdf6c400?s=96&d=mm&r=g\",\"url\":\"https:\/\/secure.gravatar.com\/avatar\/c57d7019e91373902c08eac230e003cb4f8498ecf68c9d119e9ecb82fdf6c400?s=96&d=mm&r=g\",\"contentUrl\":\"https:\/\/secure.gravatar.com\/avatar\/c57d7019e91373902c08eac230e003cb4f8498ecf68c9d119e9ecb82fdf6c400?s=96&d=mm&r=g\",\"caption\":\"Josef Spillner\"},\"description\":\"Head of the Service Prototyping Lab. Research on distributed systems and application computing paradigms. Senior lecturer at Zurich University of Applied Sciences.\",\"url\":\"https:\/\/blog.zhaw.ch\/splab\/author\/spio\/\"}]}<\/script>\n<!-- \/ Yoast SEO Premium plugin. -->","yoast_head_json":{"title":"Reflections on Teaching Serverless and Cloud-native Application Development - Service Prototyping Lab","robots":{"index":"index","follow":"follow","max-snippet":"max-snippet:-1","max-image-preview":"max-image-preview:large","max-video-preview":"max-video-preview:-1"},"canonical":"https:\/\/blog.zhaw.ch\/splab\/2019\/10\/28\/reflections-on-teaching-serverless-and-cloud-native-application-development\/","og_locale":"en_GB","og_type":"article","og_title":"Reflections on Teaching Serverless and Cloud-native Application Development","og_description":"With the proliferation of hybrid cloud, cross-cloud and post-cloud environments, finding the right concepts and tools to produce mixed-technology applications and services remains challenging. At Zurich University of Applied Sciences, a course on Serverless and Cloud-native Application Development (SCAD) prepares bachelor students in computer science for facing these challenges. We argue that this is the [&hellip;]","og_url":"https:\/\/blog.zhaw.ch\/splab\/2019\/10\/28\/reflections-on-teaching-serverless-and-cloud-native-application-development\/","og_site_name":"Service Prototyping Lab","article_published_time":"2019-10-28T17:41:46+00:00","article_modified_time":"2019-10-29T11:05:18+00:00","og_image":[{"url":"https:\/\/blog.zhaw.ch\/splab\/files\/2019\/10\/scadbg.jpg","type":"","width":"","height":""}],"author":"Josef Spillner","twitter_card":"summary_large_image","twitter_misc":{"Written by":"Josef Spillner","Estimated reading time":"8 minutes"},"schema":{"@context":"https:\/\/schema.org","@graph":[{"@type":"Article","@id":"https:\/\/blog.zhaw.ch\/splab\/2019\/10\/28\/reflections-on-teaching-serverless-and-cloud-native-application-development\/#article","isPartOf":{"@id":"https:\/\/blog.zhaw.ch\/splab\/2019\/10\/28\/reflections-on-teaching-serverless-and-cloud-native-application-development\/"},"author":{"name":"Josef Spillner","@id":"https:\/\/blog.zhaw.ch\/splab\/#\/schema\/person\/33a5227c6cc1fa3329279d33c3cc440e"},"headline":"Reflections on Teaching Serverless and Cloud-native Application Development","datePublished":"2019-10-28T17:41:46+00:00","dateModified":"2019-10-29T11:05:18+00:00","mainEntityOfPage":{"@id":"https:\/\/blog.zhaw.ch\/splab\/2019\/10\/28\/reflections-on-teaching-serverless-and-cloud-native-application-development\/"},"wordCount":1606,"commentCount":0,"image":{"@id":"https:\/\/blog.zhaw.ch\/splab\/2019\/10\/28\/reflections-on-teaching-serverless-and-cloud-native-application-development\/#primaryimage"},"thumbnailUrl":"https:\/\/blog.zhaw.ch\/splab\/files\/2019\/10\/scadbg.jpg","keywords":["cloud application","cloud-native","faas","microservices","public cloud","serverless","workflows"],"articleSection":["Education"],"inLanguage":"en-GB","potentialAction":[{"@type":"CommentAction","name":"Comment","target":["https:\/\/blog.zhaw.ch\/splab\/2019\/10\/28\/reflections-on-teaching-serverless-and-cloud-native-application-development\/#respond"]}]},{"@type":"WebPage","@id":"https:\/\/blog.zhaw.ch\/splab\/2019\/10\/28\/reflections-on-teaching-serverless-and-cloud-native-application-development\/","url":"https:\/\/blog.zhaw.ch\/splab\/2019\/10\/28\/reflections-on-teaching-serverless-and-cloud-native-application-development\/","name":"Reflections on Teaching Serverless and Cloud-native Application Development - Service Prototyping Lab","isPartOf":{"@id":"https:\/\/blog.zhaw.ch\/splab\/#website"},"primaryImageOfPage":{"@id":"https:\/\/blog.zhaw.ch\/splab\/2019\/10\/28\/reflections-on-teaching-serverless-and-cloud-native-application-development\/#primaryimage"},"image":{"@id":"https:\/\/blog.zhaw.ch\/splab\/2019\/10\/28\/reflections-on-teaching-serverless-and-cloud-native-application-development\/#primaryimage"},"thumbnailUrl":"https:\/\/blog.zhaw.ch\/splab\/files\/2019\/10\/scadbg.jpg","datePublished":"2019-10-28T17:41:46+00:00","dateModified":"2019-10-29T11:05:18+00:00","author":{"@id":"https:\/\/blog.zhaw.ch\/splab\/#\/schema\/person\/33a5227c6cc1fa3329279d33c3cc440e"},"breadcrumb":{"@id":"https:\/\/blog.zhaw.ch\/splab\/2019\/10\/28\/reflections-on-teaching-serverless-and-cloud-native-application-development\/#breadcrumb"},"inLanguage":"en-GB","potentialAction":[{"@type":"ReadAction","target":["https:\/\/blog.zhaw.ch\/splab\/2019\/10\/28\/reflections-on-teaching-serverless-and-cloud-native-application-development\/"]}]},{"@type":"ImageObject","inLanguage":"en-GB","@id":"https:\/\/blog.zhaw.ch\/splab\/2019\/10\/28\/reflections-on-teaching-serverless-and-cloud-native-application-development\/#primaryimage","url":"https:\/\/blog.zhaw.ch\/splab\/files\/2019\/10\/scadbg.jpg","contentUrl":"https:\/\/blog.zhaw.ch\/splab\/files\/2019\/10\/scadbg.jpg"},{"@type":"BreadcrumbList","@id":"https:\/\/blog.zhaw.ch\/splab\/2019\/10\/28\/reflections-on-teaching-serverless-and-cloud-native-application-development\/#breadcrumb","itemListElement":[{"@type":"ListItem","position":1,"name":"Startseite","item":"https:\/\/blog.zhaw.ch\/splab\/"},{"@type":"ListItem","position":2,"name":"Reflections on Teaching Serverless and Cloud-native Application Development"}]},{"@type":"WebSite","@id":"https:\/\/blog.zhaw.ch\/splab\/#website","url":"https:\/\/blog.zhaw.ch\/splab\/","name":"Service Prototyping Lab","description":"A Blog of the ZHAW Zurich University of Applied Sciences","potentialAction":[{"@type":"SearchAction","target":{"@type":"EntryPoint","urlTemplate":"https:\/\/blog.zhaw.ch\/splab\/?s={search_term_string}"},"query-input":{"@type":"PropertyValueSpecification","valueRequired":true,"valueName":"search_term_string"}}],"inLanguage":"en-GB"},{"@type":"Person","@id":"https:\/\/blog.zhaw.ch\/splab\/#\/schema\/person\/33a5227c6cc1fa3329279d33c3cc440e","name":"Josef Spillner","image":{"@type":"ImageObject","inLanguage":"en-GB","@id":"https:\/\/secure.gravatar.com\/avatar\/c57d7019e91373902c08eac230e003cb4f8498ecf68c9d119e9ecb82fdf6c400?s=96&d=mm&r=g","url":"https:\/\/secure.gravatar.com\/avatar\/c57d7019e91373902c08eac230e003cb4f8498ecf68c9d119e9ecb82fdf6c400?s=96&d=mm&r=g","contentUrl":"https:\/\/secure.gravatar.com\/avatar\/c57d7019e91373902c08eac230e003cb4f8498ecf68c9d119e9ecb82fdf6c400?s=96&d=mm&r=g","caption":"Josef Spillner"},"description":"Head of the Service Prototyping Lab. Research on distributed systems and application computing paradigms. Senior lecturer at Zurich University of Applied Sciences.","url":"https:\/\/blog.zhaw.ch\/splab\/author\/spio\/"}]}},"_links":{"self":[{"href":"https:\/\/blog.zhaw.ch\/splab\/wp-json\/wp\/v2\/posts\/1002","targetHints":{"allow":["GET"]}}],"collection":[{"href":"https:\/\/blog.zhaw.ch\/splab\/wp-json\/wp\/v2\/posts"}],"about":[{"href":"https:\/\/blog.zhaw.ch\/splab\/wp-json\/wp\/v2\/types\/post"}],"author":[{"embeddable":true,"href":"https:\/\/blog.zhaw.ch\/splab\/wp-json\/wp\/v2\/users\/203"}],"replies":[{"embeddable":true,"href":"https:\/\/blog.zhaw.ch\/splab\/wp-json\/wp\/v2\/comments?post=1002"}],"version-history":[{"count":15,"href":"https:\/\/blog.zhaw.ch\/splab\/wp-json\/wp\/v2\/posts\/1002\/revisions"}],"predecessor-version":[{"id":1046,"href":"https:\/\/blog.zhaw.ch\/splab\/wp-json\/wp\/v2\/posts\/1002\/revisions\/1046"}],"wp:attachment":[{"href":"https:\/\/blog.zhaw.ch\/splab\/wp-json\/wp\/v2\/media?parent=1002"}],"wp:term":[{"taxonomy":"category","embeddable":true,"href":"https:\/\/blog.zhaw.ch\/splab\/wp-json\/wp\/v2\/categories?post=1002"},{"taxonomy":"post_tag","embeddable":true,"href":"https:\/\/blog.zhaw.ch\/splab\/wp-json\/wp\/v2\/tags?post=1002"},{"taxonomy":"features","embeddable":true,"href":"https:\/\/blog.zhaw.ch\/splab\/wp-json\/wp\/v2\/features?post=1002"}],"curies":[{"name":"wp","href":"https:\/\/api.w.org\/{rel}","templated":true}]}}