Didaktics of media: Learning unit three – Report

This blog post is one part of the series “learning diary” for a course at my university.

Goal of this report is to take and rate a online learning unit. For the third learning unit we should take either a webinar or a MOOC. I participated in the course Design 1o1 Redux – Part 2: My House from the Iversity platform.

Short synopsis of the unit:

The course “Design 1o1 Redux – Part 2: My House” was the second of three courses on the platform Iversity created by the Design 1o1 Community. The target group was everyone who is interested in learning some basic design attitudes.

For eight weeks every day an email with a task was sent to all participants (I only attended one week). The mail (and the corresponding page on the Iversity platform) consisted of a short video (~15 seconds) with an abstract content. The content (mashups of drawing and images) was accomplished by a short introductory text.

The task for every day was written in a *.pdf file which consisted of four to six pages. Additional to the task there have been added some background information, learning goals, reasoning (“Why do we do this?”) and questions to interest one further.

All tasks were related to “My House” and in the one week I attended to the topic “My Room”. The overall goal of this week was to create some pictures in a Minecraft-like world and upload these pictures to Instagram (see them here).

After the first week all participants were asked to grade seven fellow participants based on six categories and three sub categories each. The grading criteria had been predefined. Two weeks after the start of this course every grading participant received their own grading.

My received grading

Reflection on your personal learning experience

I choose the course to learn something I didn’t had the faintest clue of. I hadn’t had contact with any design related topics beside software design. Therefore, I’ve been curious what I’ll have to do as well what I’ll learn.

The first task had been trivial (installing a Minecraft-like game, finding a good place for our room and make three screenshots which should be uploaded). Yet even on this trivial task I learned to transport ideas to other environments. It took me a while to find a “good” place for my room, mostly because I didn’t know what I was looking for, until I found it. My perfect place needed to be at the shore and a village needed to be in sight.

I learned to transport my room in another world. This world hadn’t had everything I needed but I found the abstract concept I was looking for.

The second task was to measure our own room and transport this in the Minecraft-like world. The participants were asked to take on of the blocks from the world and define a measurement for all dimensions. Also we were asked to make an image with our rooms overall proportions. I created that one in Excel, using different border styles to create a folding instruction of my room.

I learned about myself that I’m missing some key skills in image manipulations. And that I’m a very used to Excel. Also I choose to take the default measurement of Minecraft (1m x 1m x 1m) which wasn’t a good Idea.

For the third task we created a “colour palette” of all blocks we wanted to use in the construction of our room. This palette then should be used to create our boundaries or walls of the room.

I learned that I had no clue about colours and how they work together.

The fourth task was an abstraction task. The participants were tasked to take an object of their room (a lamp, a chair, etc. …) and abstract this object in the Minecraft-like world, honouring the measurements of the second task and not using different material other than the palette from the fourth task.

I learned to abstract my room… Given my colour palette and the measurements my abstractions needed to be… very abstract. Two blocks were my desk; another block my PC…
My room, with abstract desks, a couch and my pc on the desk

The final task was to “step into the Minecraft-like room”. With some kind of image editing we were tasked to integrate us in our newly created room. I replaced the Minecraft arm one always can see in the game with a picture of my own arm.

I learned how to make my Minecraft world more “real” with replacing my hand. That way the real world and the Minecraft world had been connected in some way.

After one week of this course I was asked to rate seven other participants. After seeing the other contributions, I found out, I really am an uncreative guy. There have been extremely creative images on the submitted pages, both from a technical view (how they created the images, the quality of the implementation) as well as the conception view (interesting ideas, very abstract topics).

I learned that there are many different ways to interpret the task. I’ve seen some good contributions which had been so essentially different to mine, although we all had the same task.

Did you achieve the stated learning goals?

The learning goal was to “Develop some basic design attitudes for better understanding the mechanics of today’s world”. I think this goal (or better, the achievement of the goal) is very hard to measure. I definitely learned some design ideas. Yet I wouldn’t dare to claim that I now understand the mechanics of today’s world better.

On the other hand, this is the stated learning goal for the whole eight-week course, so maybe I would achieve the goal in the next seven weeks. But honestly I doubt that. The tasks are too abstract for me to get connected to any real world mechanics.

Nonetheless I learned some things about myself and my abilities. At least that was a good thing.

Did the given time suffice?

The time frame which is given by the “Didaktics of Media” course for our e-learning assessments is around 90 minutes. I did not manage to get this course done in that time frame.
The assumed workload of the Iversity course “Design 1o1 Redux – Part 2: My House” itself is between four to seven hours. I needed 5 hours and 30 minutes to complete all tasks plus the time needed to evaluate my peers (additional 30 minutes). The assumed time from the Iversity course is sufficient to finish the course (albeit other participants maybe took longer, judging by their high quality contributions.

Comment on the design – what was good, what could be made better?

The design of the course was satisfying. The many small tasks and the intermediate feedback (other people in the course “like” your Instagram images) had been a nice touch. The tasks build up one another and this motivates you to not skip a task.

Also the theme was nicely integrated in all tasks. All task revolved around “My Room” (and with the next weeks-tasks) the overall course will take the “My House” topic in consideration.

One of the drawbacks of the design had been the *.pdf files. They have been to big (or the plugin used to display them was to slow). The site often froze for several seconds if the *.pdf was used.

Positive and negative aspects of the contents of the unit

Positive:

  • The tasks have been described in detail (what to do, where to upload, how to tag)
  • The allocated time was sufficient
  • The tasks have been very divers (building, abstraction, image manipulation, drawing…)

Negative

  • The *.pdf watcher in the platform was slow (maybe to big)
  • The *.pdf files were very cluttered. Lots of images, different colours, the background wasn’t ideal (see next image).
  • The grading was not ideal. The given grading criteria discriminated the really creative people contributions.
  • The introductory videos had no meaning to me.

Cluttered text

Grade the course on a scale of 0-10.

I would grade this course with a seven out of ten. I was satisfied with this course in overall, but I did not reach the stated learning goal (not even 1/8 of the learning goal, as I did only one of eight weeks). Maybe my rating is too harsh in this case but I assumed a bit more.
In the end I used Minecraft as a tool to transport my room in another world. That was not what I assumed when I read about “Develop some basic design attitudes”.

Other comments

It was the first time I uploaded something to Instagram but it was a nice way to show everyone his work and see the work of the other participants.

Update: This was my first post written with the Open Live Writer of which I heard from Scott Hanselman. I needed to update some small format bugs.

Powershell cmdlets with dynamic param AND $args don’t work

Over the weekend I tried to implement auto completion in Elixir’s  mix (in Windows). Unfortunately I didn’t make it without introducing some problems. So I didn’t committed my changes to upstream. Currently I try to reach some of the more renowned Elixir/Windows contributors, to discuss the changes .

Motivation

Under normal circumstances I don’t use more mix tasks then test, phoenix.server and release but sometimes you need this weird command, you just can’t remember. The command mix help  is your friend here as it shows you all available commands (project aware!). Yet I don’t like to look the documentation up, if I need just some information on spelling. For example in the beginning I often tried to start the phoenix project with mix phoenix.start (Hint: that does not work). I am used to auto completion in my development environments so I tried to extend mix  as well.

Background

As I am using the Powershell for all my command line related tasks and the default file extension of Powershell is ps1, my command mix  execute the mix.ps1  in the Elixir bin folder.

Approach

Powershell scripts can have auto completion of parameters with an so called [validateSet("Param1","Param2",...)] , which incorporate all valid parameters. Sadly this is of no help, if we have to hard code the possible values for the parameter. A possible solution to this problem is the usage of a DynamicParam with dynamic validateSet (good resource here). To test my various iterations I wrote down all test cases (sorry no automated testing yet).

Iteration 1

Changes

If you have a look at the original mix  script (here) you can see that the script locates the mix.bat , flattens possible array arguments (is this still needed?) and then execute the mix.bat  with the newly flattened arguments.

The first problem we see here is the usage of the $args array. As Keith Hill points out in this SO comment the $args array “… contain any argument that doesn’t map to a defined function parameter…”. Which introduces the first problem: The DynamicParam  ONLY works for defined function parameters.

I copied the linked resource (again, here) and moved the old script to the process block. Because we are creating a script and not a function the signature of function Test-DynamicValidateSet {...}  needs to be removed. To generate the validateSet I replaced the line $arrSet = ... with

This populates the $arrSet  with all valid task. I also changed the value of the variable $ParameterName  to 'Task'  and renamed the variable $Path  to $Task

Test

A short test shows, the command mix  does work, the command mix help  does not. Reason for that is, we assign the first value to the parameter $Task .

Iteration 2

Changes

The call to mix.bat in the last row now get the $Task parameter as well:

Test

mix  works, mixd help  works. Awesome! Lets try auto completion. mix [tab]  …

This is weird. The auto completion takes it times (this is actually the time mix help --names  takes to return all valid tasks) yet the auto completion fills in file names from that folder… To fix that we need to make it clear, that our dynamic parameter is actually the first parameter. So after we set the $ParameterAttribute.Position = 0  (it was 1) we repeat our test.

mix  works, mixd help  works, mix [tab]  works, mix he[tab]  works also. What about arguments to parameters? like mix help --names ?

Damn.

Iteration 3

Changes

OK, we need positional arguments. Lets add some.

I don’t like that approach, because this script will fail on having more than seven parameters (our dynamic and $p1  – $p6 ) with the aforementioned error message.

We also have to forward our new parameters to the mix.bat :

OK, besides the now unused “flatten possible array parameter” logic and our “it will fail on having eight or more parameters” problem, how good are we?

Test

All tests in the test cases pass. Yet we have some unfinished problems.

Problems with this solution

  1. We can have only a fixed amount of parameters. This is not a big problem (as we can add more parameters in the signature), but this is neither elegant nor good practice.
  2. We now completely omit the “flatten array logic”. I have to admit, I’m not sure if  this is still needed, so I asked the original contributor of this logic but still wait for response.
  3. Most of the code was copied from our resource. We clearly added some of our own logic, yet we probably shouldn’t use this code without asking for permissions. I asked the author if I could use this snippet and wait for a response.
  4. Even if I omit the “flatten array logic” I tripled the Lines Of Code. I don’t know if the auto complete feature is worth this much code (read about code as a liability here)

As soon as the problem 3 is clarified I will upload the file here. As soon as the other problems are clarified (and/or fixed) I create a pull request in GitHub to upstream the changes.

Didaktics of media: Designing MOOCs

This blog post is one part of the series “learning diary” for a course at my university.

Goals:

Based on the title for that unit I assume we will learn something about designing MOOC. The linked article on the other hand, features a paper about the Tech Ed Revolution, which “will be the Learner Revolution”. It goes on and on about investors needing to put money in education (either traditional education or start ups) and how these start ups could fuel the next learning revolution.

What have I learned:

A MOOC is a massive open online course with thousands of participants.

The two types of MOOCs are

  • CMOOC – Cooperative MOOC . MOOCs where all participants has to cooperate and work together.
  • XMooc – Extended MOOC. Classes of Universities where non students can watch the videos as well.

My University is one of the first Universities which can self accredit a course!

Designing MOOC

The main parts on designing a MOOC is conception, production, execution and evaluation.

Conception

Why do I want to serve MOOC? It’s cool, it makes money, I want to transfer knowledge. You need to define goals.

For whom do I create MOOC? For everyone? For Students? For Users of a technology? For employees of a company? For a community of special topic?

Which content has my MOOC? The language is important and has influence on the target group. The content is important as well. The length is good to have 6-8 weeks. What is the structure of the content.

What format has my MOOC? CMOOC or xMOOC? Is it self-paced or synchronous? Which tools are you gonna use for communication? Will there be gamification elements? Is there a certificate offered?

Attention: Do you have all the rights to ALL your used content? Images in slides? Videos, the tools which are needed for doing the tasks.

Under which conditions is my content published? See CC Matrix. Make it clear if one can use it in which ways.

Costs: The Hasso Plattner Institut plans $50000 for a MOOC. Simple MOOCs are possible starting at $10000.

Production

Think about marketing. Offer them for example on class-central.com. Advertise them early on.

Promovideo: Declare content, organisation of the course

Webcam vs. real camera

Postproduction is needed

Should the quizzes be peer graded or automatically graded? You need to create unique questions. Watch cultural specialties.

Execution

Evaluation

Use an internal or external tool?

Does the MOOC needed to be archived?

Elixir, Phoenix and Windows: Some insights on my 1000┬Ás problem

On Saturday I wrote about “Elixir, Phoenix and Windows: No faster responses than 1000 microseconds?“. I described two problems I had with Phoenix in Windows: My response times seem to be stuck at 1000 microseconds and Powershell couldn’t display the μ sign. I dug into some code and the mailing lists and found (with a lot of help) some answers.

1000 Microseconds on Windows?

The response times in Phoenix are often measured in Microseconds. Yet on Windows you won’t see any requests faster than 1000 Microseconds. That’s not because of a slower OS, but a not as precise as needed timer:

On Windows a developer has several options to get the system time. According to windowstimestamp.com there are (including the precision):

  • The time service (1 ms)
  • The performance counter (between 1 ms and 1 μs)
  • The GetSystemTimeAsFileTime API (100 ns)

The highest precision (100 nano seconds) can be achieved with the GetSystemTimeAsFileTime API (or the GetSystemTime API, which is the same data but differently formatted).

Actually this is the API  the Erlang VM (which provides the run time for Elixir and Phoenix) is using. So in theory we should be able to get more precise data out of these API. Yet the Erlang VM only returns millisecond as smallest unit. I’m pretty there are reasons for it, but I don’t understand them. If you are curious (and don’t fear a little bit C code) go ahead and look at the implementation of the timing in Erlang: sys_time.c in Erlang VM

1000┬Ás instead of 1000μs?

The second problem I had on saturday was the missing μ sign in my Powershell environment. I got hinted that I have to set the code page of Powershell to UTF8:

This fixed the problem for me. Unfortunately this introduced another, more grave bug to me: On putting out special characters in iex.bat, iex now fails to react completely. Until this bug is fixed, I strongly advise against this fix.

Elixir, Phoenix and Windows: No faster responses than 1000 microseconds?

If you read around phoenix developers you often hear stuff like “Awesome, requests served in under xxx microseconds!”. Yet if I try the Phoenix framework, I only have this results:

With special emphasis on [info] Sent 200 in 1000┬Ás . Here we have two problems:

  1. It looks like the command line doesn’t know the μ sign and replaces it with ┬Á.
  2. Did it really take 1000 microseconds to serve the request? I’m not sure, but I NEVER have a request faster than that. Sometimes I have a slower request (163 milliseconds on startup for example) but never faster than 1000 microseconds.

Locating the error source

Lets find the culprit: I use the Powershell to start the Phoenix app. Can Powershell show the μ sign?

Powershell using the μ sign
It can!
Powershell showing off and uses the the μ sign as variable name
Variables with the μ sign are possible as well

As a matter of fact, you can use the μ sign as variable, if you want to.

So Powershell is good. What’s the problem then? Looking into the mix.ps1 we can see that it executes the mix.bat, which executes the elixir.bat which either executes erl.exe or werl.exe. So lets have a quick look if the cmd (*.bat files are executed by cmd) is capable of the microsecond sign.

Also the command line is can show the sign
Also the command line can show the sign

So the problem isn’t the command line either. I printed the final executed call to erl.exe and executed this command without the cmd as middle man. The problem remained. So I assume it is a problem with either the erl.exe (if I use the –werl command line switch, werl.exe gets executed, the phoenix app gets started but no info is shown in werl.exe), Elixir, Phoenix or some of the plumbing in between.

Lets test Elixir. I created a new Elixir app mix new micro_second_test  and wrote a single function in it:

When starting the application with iex.bat -S mix  and executing the function we get this result:

So we can rule out Phoenix as Elixir already has that problem. What about erl.exe?

Erlang can show the μ sign. So the culprit is either Elixir or the plumbing. I will open an GitHub Issue for this problem. For the second problem (never showing less than 1000μs) I am not sure how to check. I think it could be in the cowboy web server, or in the Plug.Conn. But I have no clue…

Elixir on Raspberry Pi 2 (using Windows)

Goal

Deploy an example Elixir application with the Nerves-Project to a Raspberry Pi 2, using an Ubuntu guest in VMware Player on a Windows host.

Synopsis

We are using the Nerves-project, buildroot and Ubuntu in a virtual machine to create a SD-Image, which contains the default application, blinky.

Motivation

After seeing this talk from Garth Hitchens on Embedded Elixir in Action I wanted to try the Nerves project to deploy an Elixir application to my Raspberry Pi 2. Yet, as I’ve blogged before I’m using a Windows machine and most of the build tools (for Raspberry Pi) are using Linux.

Prerequisites

We will need to install different software to our computer, therefore I assume you have the rights to do so. Also we need disk space (around 15 Gigabytes). Because we are using a virtual machine it does not hurt to have a beefy computer. More RAM+CPU = Better.

Steps

There are several steps needed to complete our goal, most of them require some Linux usage. Bear with me, we will make it! (Also have a look at Linux for Dummies)

Install VMware Player (10 Minutes)

On your Windows Computer do:

We will install a Hyper Visor on our computer. A Hyper Visor enables you to have an operating system in your original operating system (without the risk to destroy your computer).

There are several Hyper Visor solution available. On Windows 8 and 10 the Microsoft HyperV software is available (and installed by default, I think?). In general I would go with the defaults, but I deactivated HyperV for various reasons in the past (no 3d virtualization being one of the most pressing reasons) and choose VMware Player.

After installation of VMware player download the Ubuntu 14.04 (64bit )LTS server image (or the desktop image, I don’t care). So far, 32 WONT WORK!

Create a virtual machine (5 Minutes)

On your Windows Computer do:

Start VMware player and hit “create a new virtual machine”. In the wizard window choose the “Installer disc image file (iso)” option and select your previously downloaded Ubuntu server image.

Hit next and go along with the defaults* until it finishes.

* If you are constrained on the disk size, you can reduce it from 20 Gb to 10Gb. I tried it with 5Gb but failed on downloading all the needed tools.

Install Ubuntu 14.04 LTS (30 Minutes)

In the virtual machine do:

Start your virtual machine (green arrow) and go along with the installation defaults. I changed some aspects which I will highlight now:

  • Language: I’m using German as system language and as keyboard layout.
  • Encrypt File System: I politely declined. I couldn’t care less on this build machine. Also this is in theory a minor performance drain.
  • Packages to install: I checked the OpenSSH box

Let the installation finish. It will take some time and ask questions in between instead on the beginning. So have an eye on that. As a side note. Remember username and password. We need it. For convenience use KeePass 2 or similar software.

Get IP Address (1 Minute)

In the virtual machine do:

Finally we can log in. For later usage we need the IP address. After you logged in, enter

in the terminal. This will bring up the network interface configuration. We need the IP address of the interface eth0. In my case the line looks like

We only need the address: 102.168.62.129 in my case.

Install Nerves (10 Minutes + 45 Minutes of waiting…)

In the virtual machine do:

I installed everything in my home folder, but fell free to do so where ever you like (but remember it later on :-P)

Update your package sources:

The following code is provided by the Nerves-Project:

At this point the Nerves tutorial could be more on the point. They state “…  Change to the nerves-system-br directory…” yet there is no such folder. To fix this clone the Nerves-project/nerves-system-br project from Github!

Now we can change in the nerves-system-br folder:

Now we can follow the tutorial on the nerves-project Github page along again:

And now to kickstart the future “real” builds: Lets make a dry run to cache all files (this maywill take a while):

This takes around 45 Minutes.

Using Nerves (10 Minutes)

The tutorial states one has to source the environment. This sets some variables and is needed every time one brings up a new console

For testing I cloned the blinky example from Github

change in the new folder and in the blinky directory

Now the magic can happen:

This will create a file _images/blinky.fw

*.fw is the file format for fwup (don’t worry it is already installed). After some research (and lots of help by Frank Hunleth and Garth Hitchens I We figured out the correct command:

Using this command you create we create a Raspberry Pi image file (_images/blinky.img)

Get the image (5 Minutes)

On your Windows Computer do:

The resulting image is located in your virtual machine at ~/nerves-examples/blinky/_images/ .

To access that folder we need to download the folder from the virtual machine to your Windows computer. You can access the folder via WinSCP if you opted in for the OpenSSH package before:

Open WinSCP (if installed; otherwise: DownloadChoco Package) and create a new connection. Computer name is the IP address we saved before. Username and password are your credentials from the virtual machine (I told you to remember it!).

You will be presented with two explorer views. The left side is your computer, the right side is the virtual machine, already in the home folder of your user.

If you cloned the nerves-examples.git in the home folder as I suggested, you can easily follow the path. On the right side click through the folders ~/nerves-examples/blinky/_images/ until you find your file, which is called blinky.img. Copy the file to your computer, for example on the Desktop.

“Burn” the image (15 Minutes)

On your Windows Computer do:

To burn the image we need a tool which creates the file system from our downloaded image. Follow the tutorial on RaspberryPi.org.

Fun (Countless hours)

On your Raspberry Pi do:

Insert the SD-Card in your Raspberry Pi and power it on. Depending on your setup, something should happen! For example the blinky example lets you blink the LED, the demo example (should, didn’t work for me) let you connect via ethernet.

The fun you can have
The fun you can have

History:

  • Update 23.12.2015: Added hint for 64bit after @mdsebald mentioned it
  • Update 22.12.2015: Fixed the “Get the image” part
  • Update 22.12.2015: Fixed the tutorial
  • Update 21.12.2015: Marked the tutorial as broken

Atom.io now works on German keyboards!

Summary:

If you have problems with non us-keyboards and the editor Atom.io install this package: keyboard-localization

Shortly longer:

Ok, I blogged about my problems with Atom.io before (and before) and the underlying issues aren’t fixed in the chromium parts of Atom.io. Yet there were workarounds: For example I created my own keybinding file, which fixed my most important issue the missing “@” sign (who is using that, anyway?). Now I needed an working “\” in my elixir code. I tried to fix it in the same way as I did before, but failed. Fortunately for me Andreas Scherer and David Badura created an Atom.io package which fixed all my keyboard issues with Atom.io.

So if you have a keyboard issue while working in Atom.io, which could be a localization issue give this package a try: keyboard-localization

Didaktics of media: Learning unit two – Report

This blog post is one part of the series “learning diary” for a course at my university.

Goal of this report is to take and rate a online learning unit. For the second learning unit we should take a video based course. I watched a course on the platform http://pluralsight.com.

Short synopsis of the unit:

The course “Building Highly Scalable Web Applications in Azure” is a video based course on the platform http://pluralsight.com. Pluralsight is a provider for video based online training with 3.500 courses on different topics. The courses aren’t free but there is a 10 day / 200 minutes trial. Also you can sign up for the Microsoft Visual Studio Dev Essential Program (free) and get three months of Pluralsight training for free.

The top categories of courses provided by Pluralsight
The top categories of courses provided by Pluralsight

The chosen course was an intermediate course and perceived very well (4.5 out of 5 stars with 173 ratings). I chose this course because the topic was interesting to me (I do work in a company with Microsoft stack) and I already have read some blog posts about the author. Additionally the allotted time (2hours, 23 minutes) sounded reasonably for me (there are courses worth of 15 hours) for this unit.

The title is very descriptive: The course covered some of the most important steps one have to think of, if one tries to refactor an ASP.NET MVC web application to a highly available, highly scalable Microsoft Azure application.

Reflection on your personal learning experience

I perceived this course as a great addition to my knowledge. I worked with Microsoft Azure on some private pet projects, yet hadn’t any chance (or the need) to create a highly scalable one. Because of my previous knowledge the intended audience “intermediate” was fitting well. I have to admit, that because of the length of the course I kept loose the concentration. I paused the course on two occasions but continued shortly after wards.

Did you achieve the stated learning goals?

It is hard to say if I now would be able to create a highly scalable web application in Azure without having to look some details up. None the less I feel reasonably proficient now to help in such a project and (with some details looked up) even do my own scalable project.

Did the given time suffice?

The allocated time for the eLearning units has been around 90 minutes. As I already stated, the course took two hours and 23 minutes. Therefore the time did not suffice or to put it in other words: I did choose a too long course for this unit.

Comment on the design – what was good, what could be made better?

The course design is terrific. The course is split in eight separate modules, which could be watched in any order. A sequential flow is intended though. Every module is than separated in sub modules with their own “mini-agenda”.

Pluralsight2
Table of content of the course

The video itself was well organized and the audio and video quality excellent. At the start of every module the speaker gave an overview what we will learn in this module, what these techniques will help to achieve and what the consequences would be, if these techniques got neglected. Most of the modules showed a load test at the start and the end to show the impact of the changes at a demo project. After every module a summary was drawn.

Summary on the third module
Summary on the third module

Positive and negative aspects of the contents of the unit

I am very satisfied with this course as already mentioned. If I would need to be nit-picky I could criticize the rash showings of the code of the demo project. I had to pause the video to fully understand the changes in the code.

Also one of the implemented techniques is not quite clear to me how this help in a real world application.

Grade the course on a scale of 0-10.

I would grade the course a ten out of ten but only if all minor flaws would have been resolved. Therefore I give it a nine out of ten.

Pluralsight in general and this course in special was very interesting and I’m looking forward to watch more of their videos.

Other comments

Also: I did the test afterwards and gained a Certificate of Achievement!

My Certificate of Achivement for doing the test
My Certificate of Achivement for doing the test

Update 17.01.2016: Updated the introduction. Nasty copy and Paste bug…

Didaktics of media: Learning Communities

This blog post is one part of the series “learning diary” for a course at my university.

Goals:

Based on the pdf which was provided I assume we will learn something about communities of learners. In the pdf it’s stated that the oldest definition for a university is “a community of learners and teachers”. So I assume we will learn more about the University as a community of teachers and learners. Furthermore the pdf goes on to asynchronous learning communities. Therefore I assume we will learn something about wikis, mailgroups and co.

What have I learned:

As an experiment I try to take my notes of the lesson directly on the blog. We will see how this works out.

One way to moderate an online course is Adobe Connect. Our professor showed as the instance Adobe Connect on the Deutsche Forschungs Netzwerk. She showed us the capabilities (whiteboard, Share screen, Question Answer Session, notes, chat…). One feature she mentioned some of the feedback possibilities: “Raise your hand”, “Slow Down” or “You are to quiet”.

The topic of today was Computer-supported cooperative/collaborative work/learning or CSCW/L. We did a quick round up which tools for collaboration are used by the students. She pressed the fact that you need a learning goal, especially for collaborative learning environments.

We have been informed that in the states the university is more of a community than in Germany: The teachers are doing more with the students and the students wear university stuff (more proud).

The goal of a curricular learning communities are linked classes. A linked class is a class which has different courses, often interdisciplinary, with the same set of students and teachers.

Also important is the integration of different courses: Often the math teacher has no idea what the informatics teacher does. This could lead to inefficiency. If you integrate all courses together more tightly the topics could be more aligned.

Another learning community structure is “coordinated study”. In this concept, there are no such things like courses, but all courses get blended together. So you would have for example a topic (game design) and all “courses” would revolve around these topic.

Asynchronous Learning Networks (ALNs)

There are different kinds of communities. For example there are geographic community like the life in an American Small Town.

What is a ALN? It means anytime / anyplace. Learning networks are communities of learners who work together to build and share knowledge, through computer networks. In an ALN a classroom is the platform. Be it a MOOC or a learning System.

How to build a community?

  • The teacher needs to be online. Otherwise students wont be either.
  • Immediacy is important. Without the nonverbal part a written discussion can easily be misinterpreted.

What are obstacles to virtual intimacy?

  • Paranoia – I might be revealing details about myself I don’t want stored
  • Grifters – Someone can steal my ideas
  • Bad design of the courses

Update 17.12.2015: Added What have I learned section