Everything Changed

The term ‘Vibe Coding’ was defined Andrej Karpathy, a co-founder at OpenAI in Early 2025. The basic idea is to rely entirely on Large Language Models – LLMs – and code by using only natural language prompting, rather than writing the code yourself.

Back in 2023, I published ‘Frame-IT’, an iOS app on the Apple Store, written in Swift but coded completely in the then-early version of ChatGPT. As I noted on DigitalUrban, every app has a story, from the idea through to story boarding, finding a design team, working with in house computer scientists or outsourcing. All of these steps take time, resources and often for the small ‘would be developer’ the obstacles are overwhelming, meaning that the spark of an idea often gets lost.

Yet, everything has changed, the whole landscape of developing, designing and creating has turned on its head. It has reached the point where the spark of an idea can be coded, designed, marketed and launched with the help of Artificial Intelligence. Frame-IT is a very simple app, doing a simple thing, but it came from an idea, a want, a desire to do something which before AI would have got lost in logistics, finding the time of computer scientists, and it would certainly be economically unfeasible.

The First Idea

Frame-IT came about while looking at Samsungs’ Frame Televisions, beyond the normal 4K television they blend into the background by displaying art and making the art look as it is mounted on a white background while also being enclosed in a frame – i.e. like a painting. Samsung does this well and the screens are excellent, but it is limited to art works, leading to the idea that it would be nice to frame websites, specifically ‘data’ based web sites and hang data on walls, data that changes in Realtime. Of course, any screen could be used, but if you simply show data on a screen or monitor, no one notices. If you hang it in a frame, as if its art, people will notice.

The concept was therefore simple, build an application that puts a picture frame around websites, allow users to select which websites to show and if there is more than one, cycle through them, like a dashboard. This would allow small screens, such as iPads, to act as frames and, via AirPlay, devices such as projectors or general screens to gain a look beyond their norm and display websites and data in the same way as hanging art on the wall.

The problem was, this was an idea, to code it would require knowledge of Swift, a library of ‘picture frames’ and probably a business case to justify the time of resident computer scientists (I work at University College London, so we have a few around) and to be honest it was such a simple idea I’m note sure anyone would listen. So, with the rise of AI, I decided to build it myself, using AI from start to finish, from knowing little about Swift, and only as much about AI as my then twitter feed was full of and reading articles on site such as The Verge.

The app took me two days to build, two days where I was also working, so mainly doing things in-between other tasks, over lunch and a little bit in the evenings. With the initial learning curve out the way, I could rebuild it in a day. The first things I did was sign up to OpenAI to gain access to GPT 4 , which released on March 14th 2023. This allowed me access to the latest version and therefore the most up to date knowledge base, although looking back version 3 would probably have been fine and I could have simply used the free tier. My first prompt was “Can you write me swift code to take a website, centre it and add the image of a picture frame around it’. The app should work full screen, in landscape mode”. I had a sample picture frame (taken from Wikipedia and cutting out the actual image to leave a transparent centre).

Within 60 seconds, GPT gave me a section of code and then stopped, it turns out there was a limit in the amount of characters it could respond with. A quick Google search (ironically) showed me that by typing ‘continue’ ChatGPT will continue the code. With this I became a master of cutting and pasting, with the code often taking three continues and code which while sometimes was in code boxes, was also in simply text. It also allowed me to start to understand the layout and nature of Swift, within 30 minutes i had my first app running on an iPad, via Xcode. Simply by cutting and pasting and pressing ‘play’. Not all things worked out, there were often errors, but errors I could cut and paste back into GPT and it would solve them, most of the time.

Each time a milestone was made – a working version, a version with a picture frame in and a website showing, I would save the code as Chat GPT would sometimes break the next version while I was asking for new features. Features such as ‘Add a button to move to the next website’, ‘If there is more than one website, then cycle through them every 60 seconds’ (the websites were hard-coded at this point). Once i had a concept running on my own iPad, I realised it was quite neat and decided to then adapt it so others maybe able to use it. I added a settings page – via ‘Can you delete all the websites I have added and include a settings page, the settings page should be reached via a button and have the ability to add and delete websites, once added they should be saved so the app remembers them when reopened’. This is coding but in the new language – human language.

The picture frames were created in Image Creator by Bing, a search engine I never thought I would use (being a Mac user) but in that last week I had not been near Google. Bing allowed me to type in prompt and get images without any user limits. Simple prompts such as “create me a gold Victorian picture frame, it should be photorealistic with minimum reflections and the centre should be cut out” worked amazingly well, providing me with an almost limitless range of Picture frames to include as part of the assets.

Not all the picture frames are from AI, a couple are from open source imagery, it felt wrong to cut out the picture, but the frames have some provenance and they were nice to include.

Marketing requires imagery as well – as such I took a very simple picture of my two test iPads and used the ‘PhotoRoom” AI app to transform it to two iPads on a bench with a concrete wall behind, whereas the reality was far from as glamourous.

The App is now available via the Apple Store, it even has its own website and logo – again designed by AI, designed using Looka and hosted on Framer. So while it worked, it was a little painful with the limited lengths of code in the early version of ChatGPT and the endless cutting and pasting/fixing things – it was quick, but it still took a notable commitment and time. It is also a very very niche app, but as we get to, thats the point of Vibe Coding.

And then Everything Changed Again

That was 2023 – late 2024, and everything has changed again, not only the workflow and the tools, but also the ability of the LLMs to Vibe Code, they now work, no more cutting and pasting small chunks of code, everything works. Code comes out ready to go and any errors can be fixed in a complete code base, with notably less errors compared to 2024 . As such, we made another app – again Vibe Coding, without knowing at the time – MQTTFrame.

The aim was to build on the concept of FrameIT but allow realtime data intergration directly in the app via MQTT (a lightweight, publish-subscribe network protocol for data) and to make it easy to subscribe to any MQTT topic and display live updates.

Our aim was to allow:

• Customizable Frames: Choose from multiple high-quality decorative frames to complement your home or office décor.

• Clean and Clear Data Display: Showcase important data such as temperature, pressure, news, and more with clear typography and layout.

• Fullscreen Mode: Tap to seamlessly switch to an immersive fullscreen view, maximizing readability and aesthetics.

• Easy Management: Add, edit, and reorder topics quickly through an intuitive interface.

• Instant Updates: Receive real-time data updates over MQTT, ensuring you’re always in the know.

And that’s what we did – but this time in a day and with everything created in ChatGPT – icons, graphics, code, marking text, and even walking me back through how to get it on the Apple Store (as it’s an oddly complex and easily forgotten process).

So one day Vibe Coding and an app was taken from concept to ready to publish on the Apple Store – if you want to try it its currently available for free, on the Apple Store

Everything Again and Again

That was the end of 2024, now in mid 2025 and term Vibe Coding has come into common use and Large Language Models are now more than capable of making anything from webpages to apps to writing posts (all of this was, however, written by an actual human; any grammatical errors are of course, intentional). We have now switched from ChatGPT to Google Gemini and use it almost daily to produce and make apps or webpages that perhaps only I want in my life, such as – an Asteroids Clock, made in 30 minutes (temporarily housed at – https://finchamweather.co.uk/astroidsclock.html – we will move it to Github soon as we get chance).

or a Procedural City Maker (https://finchamweather.co.uk/proceduralcity.html)

or a Weather Dashboard with the forecast made into the image of an English Landscape using data from the API from the UK Met Office:

You can view the dashboard live at https://finchamweather.co.uk/aiweatherimage.html

All small, niche things that somehow I love and I am happy that Vibe Coding allowed them to exist – that’s the magic, Vibe Coding allows you to create anything in your imagination that did not exist to exist, it’s a great time to be making digital things.

If you liked this post, please do subscribe, it gives us a good reason to write another one…

The post Vibe Coding: From iOS Apps to an Asteroid Clock and 3D Cities appeared first on Digital Urban.

There are many tutorials online on using an LED Matrix to display data—many of them require wiring up a screen, external power supplies, or flashing boards. We wanted to highlight a slightly more accessible way to get an LED Matrix—in our case, a Hub 75, 32×64 pixel up and running using an Interstate75W from Pimoroni. The benefit of the Interstate is that it plugs indirectly into the matrix and can power a single screen directly from the board.

Interstate75W

We wanted a way to display any data we wanted on the screen with the screen lighting up and data scrolling up as it arrives and then turning off. To use this we use MQTT to load our data (a test feed is included in the scripts – which displays Time, News and Environmental Information) – see below for a demo:

 

We also incorporate manual brightness control and reconnecting for the MQTT for message handling, making it easy to update the display from anywhere. Setting up your own MQTT is beyond this post, but its easier than you may think and once you have one it can be used to display any data, from external feeds such as weather apis through to data from systems such as Home Assistant. Edit April 2025, we have added additional files to allow use with the new Pimoroni Intersate Starter Kit 128×128 Matrix, allowing a larger format screen, as pictured below.

Matrix128x128

Features

• Scrolling Text Messages: Display messages that scroll across the HUB75 LED matrix.
• Manual Brightness Control: Adjust the brightness of the display manually.
• MQTT Integration: Receive and display messages via MQTT.

Hardware Requirements

To get started, you’ll need the following hardware:

• Pimoroni Interstate75W
• A HUB75 LED matrix display
• 3D Printed Case
• MQTT broker (local or cloud-based) – we provide our own feed so you can test the set up.

There is also room in the 3D printed case to attach a cloth cover, acting a diffuser (a grey t-shirt works well, cut to size):

LED Matrix with Cloth Cover

Software Requirements

You’ll also need the following software – all available from our GitHub

• MicroPython
• Required MicroPython libraries:
  • interstate75
  • mqtt_as
  • uasyncio

Setup

1. Clone the Repository

First, clone the project repository from GitHub, or just download the files directly:

“`sh
git clone https://github.com/digitalurban/Interstate75W_MQTT_Scroller
cd interstate75w-mqtt-display
“`

2. Upload the Code

Next, upload the code to your microcontroller. You can use tools like Thonny or ampy to do this.

3. Configure WiFi and MQTT

Update the config.py file with your WiFi credentials, the MQTT details can also be updated if you have your own server, if not then leave them for our demo feed.

“`python
config = {
‘ssid’: ‘your_wifi_ssid’,
‘wifi_pw’: ‘your_wifi_password’,
‘server’: ‘mqtt_broker_address’,
‘user’: ‘mqtt_user’,
‘password’: ‘mqtt_password’,
‘port’: 1883,
‘keepalive’: 60,
}
“`

Usage

Run the Script

The script will automatically connect to WiFi and the MQTT broker, then start displaying messages – our MQQ feed displays messages approximatly every 3 minutes.

Constants and Initial Setup

The script defines constants for controlling the scrolling text speed, how long the screen says on for after displaying the message and brightness settings. It also initializes the Interstate75W object:

Constants for controlling scrolling text

BACKGROUND_COLOUR = (0, 0, 0) # Black background to turn off the screen
HOLD_TIME = 2.0
BLANK_SCREEN_TIME = 10.0
BUFFER_PIXELS = 2 # Increased buffer to ensure full scroll off
SCROLL_SPEED_LEVEL = 8 # Set the desired scrolling speed level (1 to 10)
SCROLL_SPEED = 1 / SCROLL_SPEED_LEVEL # Convert to a delay in seconds

Brightness settings

brightness = 50 # Initial brightness (0 to 100)

Do let us know if you make one – we would love to see images of your own set up and we hope this made it a little easier for anyone new looking to run an LED matrix using MQTT.

The post Make a Scrolling Hub75 Matrix Display using a Pimoroni Interstate75W and MQTT appeared first on Digital Urban.

Sometimes there is a need to step back and do things as simply as possible. EInk / Epaper screens are amazing, they carrying on showing an image with zero power and the screens have a certain clarity that is hard to achieve with more standard LED offerings. The more difficult part is getting content onto them, especially content that is well designed and fits the screen.

 

Puppeteer can do many things but for our use it allows the Pi to open a webpage, take a screengrab, save it as an image and then close. This image can subsequently be served via Node Express and viewed on an eInk screen.

To make the most of eInk/epaper screens you generally grab some information using a microcontroller, such as a Node MCU or ESP32, send it to the screen and then power down. This means you can check for new information over a period of time, say, every 15 minutes, display it and then sleep, allowing your screen to be battery powered for weeks on end.

 

At the moment we are using the amazing InkPlate 6. The InkPlate 6 is built around a recycled Kindle Screen and has a built-in ESP32 controller, a lithium battery connecter/charger and perhaps, more importantly, an easy to understand library to display an image and then sleep. In the world of eInk screens, the importance of an easy to understand library really cannot be understated, some of them are notably complex. We have published the 3D printable case to Thingiverse so all you need is the InkPlate (or any other screen you want to display an image on), a script to load a webpage and some Node JS to grab the information you want to display.

 

We are using 3 variations of the same script on our ePaper display, one to grab a webpage showing environmental information, a second decoding a weather forecast from the Met Office, another showing a Rainfall radar and we cycle these every 15 minutes with the environmental information showing twice in the hour.

The information can of course be any web page you want to display, from a news site,  a social network feed, transport information or anything you want to show.

Ingredients

 

1. You will need a device capable of running Node JS, we are using a Raspberry Pi 4. We assume here that you have a Pi up and running with the full operating system installed, if not then take a look at the main Pi site for details on how to set up. If you need any help then drop us a line in the comments and we can expand this section as needs be.
2. Optional: An eInk screen and controller – we are using the InkPlate 6 and our code to load the image once grabbed is now available on GitHub. There are a number of eInk/epaper screens, the most popular ones being made by WaveShare. These will also work if you edit the example code from the libraries that allow the display of online images. Of course, you may simply want to have an automated screengrab of a webpage. Such things are useful in Unity3D to make Augmented Reality displays, for example.

Installing Node JS

The first part is to install Node.JS, thankfully Node is quick and easy to install – in your terminal enter:

 

$ curl -sL https://deb.nodesource.com/setup_15.10.0 | sudo -E bash -

The 15.10.0 represent the current version as of February 2021, change this number to the latest version as needs be – you can find out the current release via the main Node JS site. You have now made your Pi aware of where to find Node.

The next step is to install it:

 

sudo apt install nodejs

To check all is in place you can run:

 

node -v

This will tell you the version of Node you are running. You have installed Node, well done, now for the Puppeteer library.

Installing and Configuring Puppeteer

Puppeteer is a library for Node.js that allows for the control of the Chrome browser in headerless mode (i.e. you dont see it happening). This allows you to open a web page, do something with it – in our case take a screenshot – and then close chrome, all via a simple script.

Installing Puppeteer is all via a single line in the terminal:

 

npm i puppeteer --save

Now you have Node.js and Puppeteer installed, all you need now is to create a script to tell Node what to do:

We like to start a new script in a new directory called ‘Scripts’ (although it can be anywhere).

So firstly create a new directory via the terminal:

 

mkdir Scripts

Now create your first empty script, we are going to call ours ‘webpage.js’:

 

sudo nano webpage.js

Below is the javascript to cut and paste into your new script:

 

const puppeteer = require('puppeteer');
async function timeout(ms) {
  return new Promise(resolve => setTimeout(resolve, ms));
}
(async () => {
let browser = await puppeteer.launch({
          headless: true,
          executablePath: '/usr/bin/chromium-browser',
//          args: ['--no-sandbox', '--disable-setuid-sandbox']
  });
  const page = await browser.newPage();
  await page.goto('http:YourWebPageURL');
// 5 second timeout: allows the page to fully render before taking the screenshot
  await timeout(5000);
  await page.setViewport({ width: 800, height: 600});
  await page.screenshot({path: '/home/pi/Scripts/eink.jpg'});
  await browser.close();
})();

The main parts to note above are the http: where you need to add in the webpage you want to capture and the width and height of the page. This should be changed according to the resolution of your screen, the InkPlate 6 runs at 800×600 resolution. The script opens the URL, waits 5 seconds for it to fully load and then saves a screenshot as a jpg to the location of your choice.

To run your script:

node webpage.js

The script should now run, load a webpage and save the image to your Pi.

If you are running your eInk display direct from your Pi (such as using a Waveshare screen) you can stop here and point your display to the new image. If however, you are using a screen elsewhere on your network you will need to host it, this is where Node Express comes in.

Installing Node Express

As with Node and Puppeteer installing is via a simple one line command:

 

npm install express --save

To start the server and host the image, you need another script. So the same as before, create a script, we called ours server.js:

 

sudo nano server.js

Cut and paste the following:

 

var express = require('express');
var app = express();
var path = require('path');
var public = path.join(__dirname, 'public');
// viewed at http://localhost:8080
app.get('/', function(req, res) {
    res.sendFile(path.join(public, 'index.html'));
});
app.use('/', express.static(public));
app.listen(8080);

The above script runs a server at http://localhost:8080 where you can install a welcome page (index.html) if you wish but more importantly you can serve static files, in our case our screen grab eink.jpg. Note that the folder address is ‘public’ this is where you will host your files.

In our first script we now want to edit the folder where our image is saved, so we can host it as soon as it is created, so simply edit the file, (again using sudo nano webpage.js) to include the ‘public’ directory -ie /home/pi/Scripts/public/eink.jpg

If you now go to either http://localhost:8080/eink.jpg on the host machine or your http://Your IP of the PI:8080/eink.jpg you should be able to view the jpg.

All that needs to be done now is to start the server when the Pi boots and to run the webpage script every set period of time. To load different webpages simply clone the webpage.js script but with a different URL to grab and run it at a different time, as mentioned, we run 4 scripts an hour via cron jobs.

Cron Jobs

The final part is to run the server at boot and the script every 15 minutes.

Firstly go to your root directory by typing:

 

cd:

Now we want to install a new Cron Job, or edit one we have already set up:

 

sudo crontab -e

At the end of the file that opens add the following lines:

 

@reboot sudo /usr/bin/node /home/pi/Scripts/server.js
15 * * * * /usr/bin/node /home/pi/Scripts/webpage.js

Whenever the Pi reboots it will now start the server – via your server.js script and every 15 minutes run your webpage.js script to take an image of a webpage, which you can subsequently point your eInk screen to load.

It may feel like a number of hoops to jump through for a simple screengrab, but once running it opens up the wider world of Node.js and Puppeteer as well as the ability to use your eInk screen to display any webpage you want.

I hope this has been useful, do drop me a line in the comments with any thoughts or tweet me @digitalurban. It’s part of a series of new ‘how to’s’ here on digitalurban.org and over at https://connected-environments.org/

 

The post Node.JS, Node Express and Puppeteer for Epaper / EInk Displays: How to Open a Web Page & Save as an Image appeared first on Digital Urban.

The post The Little Book of Public Space and the Internet of Things appeared first on Digital Urban.

The YouTube clip below details the collection so far (Spring 2021):

Each of these objects will be explored further and made available to print, insert into 3D worlds and view online. One such example is our ‘THE’ – Time, Headlines and Environmental Data.

We have a full tutorial on making a ‘THE’ over at Connected Environments. A more recent addition is the ability to upload models to SketchFab and make them available to download.

SketchFab also allows models to be embed and viewed directly within a web browser – below is an example of our 3D Printed Barograph, using realtime data feeds combined with more traditional paper and ink to recreate the Barograph – click ‘Play’ to view the model in 3D.

We will be posting more about the Spring 2021 collection in the coming weeks. Its been a while since our last post over here on Digital Urban, it is good to be back.

The post IoT 3D Printable Devices – The Spring 2021 Collection appeared first on Digital Urban.

The post Raspberry Pi Internet Radio appeared first on Digital Urban.

The Weather Flow ‘Smart Weather Station‘ is arguably one of the most innovative weather sensors on the market. Launched via a kickstater campaign in 2017, the system is now shipping to backers and will be made available for general sale shortly.

The system consists of two current hardware modules – the Air and Sky with a third unit – Breathe focusing on air quality arriving at a future date. The Air (pictured above left) measures Temperature, Pressure, Humidity and Lightning. The Sky unit (above middle) measures wind (via ultrasonic sensors), rain (haptic sensors), Solar Radiance and Solar UV. 

Sensor data refreshes every 3 seconds via either the Weather Flow app (see smartweather.weatherflow.com/share/2701/grid for our data feed) or via a dashboard powered by various 3rd party applications.

Placing temperature and humidity in the field is not as easy as simply putting a device outside. It needs to be suitably shielded from the sun and rain as well as being at a set height (1.25m) to reduce heating from the ground. High end stations often use a ‘Stevenson Screen’ to shield instruments and to comply with international measurement standards. 

Such screens are expensive to buy and often impractical for home based weather stations. As such we decided to model and 3D print our own shield for the Weather Flow Air.

Modelled using Fusion 360 it is designed to be made on a standard 3D printer, apart from the screws required to fix it to a post. We used the Ultimaker 3.

The model consists of 6 separately designed parts – top and bottom mounts, middle sections,  rods, nuts and spacing washers (again all printed) – and is designed to be easy to print and assemble. Everything slides into place without any need for gluing or fixing.

Each part was sanded (1000 and 400 grit), primed and sprayed with gloss white paint – although this is not an essential, it can simply be 3d printed. The Weather Flow air sits inside and the parts act as a shield against radiation and the sun.

All the parts are available on Thingiverse, Weather Flow makes its data available via UDP, opening up opportunities to link to systems such as Node Red or any number of data displays/home hub devices. We will have more of that in future posts.

Btw – Digital Urban is back, its been a long time since the last post – with a focus on connected environments, sensors and sensor validation, data visualisation and 3D systems its good to be back online –  after a long stint as Head of Department (and various other things) at the Centre for Advanced Spatial Analysis, University College London.

The post 3D Printing a Radiation Shield for the Weather Flow Air appeared first on Digital Urban.

Citydashboard

Weather Data Dashboard

Encoding and Overlaying Data

The post Streaming Urban Data – YouTube Live appeared first on Digital Urban.

As Course Director, i am pleased to announce the new MSc and MRes in Smart Cities, here at the The Bartlett Centre for Advanced Spatial Analysis. Both the MSc and MRes offer an innovative and exciting opportunity to study at UCL – with key training for a new career in the emerging Smart Cities market. Smart cities are focused on how computers, data, and analytics which consist of models and predictions, are being embedded into cities. Cities  currently are being extensively wired, thus generating new kinds of control and new kinds of services, which are producing massive data streams – ‘big data’.  To this end, we need powerful analytics to make sense of this new world with a new skill set to understanding and lead this new field.
CASA
The Bartlett Centre for Advanced Spatial Analysis (CASA) is one of the leading forces in the science of cities, generating new knowledge and insights for use in city planning, policy and design and drawing on the latest geospatial methods and ideas in computer-based visualisation and modelling.
CASA’s focus is to be at the forefront of what is one of the grand challenges of 21st Century science: to build a science of cities from a multidisciplinary base, drawing on cutting edge methods, and ideas in modeling, complexity, visualisation and computation. Our current mix of architects, geographers, mathematicians, physicists, urban planners and computer scientists make CASA a unique department within UCL.
Our vision is to be central to this new science, the science of smart cities, and relate it to city planning, policy and architecture in its widest sense.

London – A Living Lab

EDUCATIONAL AIMS OF THE PROGRAMME
The MSc Smart Cities and Urban Analytics comprises 180 credits which can be taken full-time over 12 months or on a flexible modular basis of up to 5 years duration (full details of the MRes structure can be found here.  If taken full time over one year, the following structure is followed:
TERM ONE
Smart Systems Theory
The module provides a comprehensive introduction to a theory and science of cities. Many different perspectives developed by urban researchers, systems theorists, complexity theorists, urban planners, geographers and transport engineers will be considered, such as spatial interactions and transport models, urban economic theories, scaling laws and the central place theory for systems of cities, growth, migration, etc., to name a few. The course will also focus on physical planning and urban policy analysis as has been developed in western countries during the last 100 years.
The class runs during term one, for two hours per week
Assessment is by coursework (2,500 – 3,000 words)
Quantitative Methods
This module will empower you with essential mathematical techniques to be able to describe quantitatively many aspects of a city. You will learn various methodologies, from traditional statistical techniques, to more novel approaches, such as complex networks. These techniques will focus on different scales and hierarchies, from the micro-level, e.g. individual interactions, to the macro-level, e.g. regional properties, taking into account both discrete and continuous variables, and using probabilistic and deterministic approaches. All these tools will be developed within the context of real world applications.

The class runs during term one, for two hours per week

Assessment is by a mix of presentations and coursework

Geographic Information Systems and Science

GI Systems and Science aims to equip students with an understanding of the principles underlying the conception, representation/measurement and analysis of spatial phenomena. It presents an overview of the core organising concepts and techniques of Geographic Information Systems, and the software and analysis systems that are integral to their effective deployment in advanced spatial analysis.The practical sessions in the course will introduce students to both traditional and emerging technologies in geographical information science through the use of desktop GIS software like Arc GIS and Quantum GIS, and the powerful statistical software environment, R. In developing technical expertise in these software tools, students will be introduced to real-world geographical analysis problems and, by the end of the course, will be able to identify, evaluate and process geographic data from a variety of different sources, analyse these data and present the results of the analysis using different cartographic techniques.

The class runs during term one, for three hours per week (one hour lecture followed by two a hour practical)
Assessment is by coursework (2,500 – 3,000 words) and via an exam

This module introduces you to the tools needed to manipulate large datasets derived from Smart Cities data, from sensing, through storage and approaches to analysis. You will be able to capture and build data structures, perform SQL and basic queries in order to extract key metrics. In addition, you will learn how to use external software tools, such as R, Python, etc., in order to visualise and analyse the data. These database statistic tools will be complemented by artificial intelligence and pattern detection techniques, in addition to new technologies for big data.
The class runs during term two, for two hours per week
Assessment is by project output (5,000 – 6,000 words)
Urban Simulation
The module provides the key skills required  to construct and apply models in order to simulate urban systems. These are key in the development of smart cities technologies. You will learn different approaches, such as land-use transport interaction models, cellular automata, agent-based modelling, etc., and realise how these are fashioned into tools that are applicable in planning support systems, and how they are linked to big data and integrated data systems.  These models will be considered at different time scales, such as short-term modelling, e.g. diurnal patterns in cities, and long term models for exploring change through strategic planning.
The module runs during term two, for two hours per week
Assessment is by coursework (2,500 – 3,000 words)

The Hidden Data City

The post Introducing the MSc and MRes Smart Cities at the Bartlett Centre for Advanced Spatial Analysis appeared first on Digital Urban.

UCL Quad in the Snow London 2050

The post Happy Christmas and a Happy New Year (Movie) appeared first on Digital Urban.