When I started working at Clever Cloud, I spent some time messing around with the platform and its tooling. This blog post will present you how I managed to:

• create a simple Scala/Akka HTTP template application with PostgreSQL persistence
• link the application to a managed PostgreSQL
• deploy it
• try it!

Create a Scala/Akka HTTP template 🔨

Get the sources

Clone the project generated from Akka Github quick start template.

This service provides the ability to manage a simple in-memory user registry exposing 4 routes:

• List all users
• Get a specific user
• Create a user
• Delete a user

A thorough description of available the cURL commands may be found here.

Add extra features

A few functionalities have been added on top of the original example:

• store the registry into a PostgreSQL database (instead of in memory)
• read database parameters from environment variables
• add a hardcoded basic authentication

All parameters may be specified in the application.conf file:

• basic auth
• database parameters

Parameters are fetched from environment variables, or the specified default value if none is found

app {
  basic-auth {
    user = "foo"
    user = ${?BASIC_AUTH_USER}
    password = "bar"
    password = ${?BASIC_AUTH_PASSWORD}
  }
  routes {
    # If ask takes more time than this to complete the request is failed
    ask-timeout = 5s
  }

  db {
    host = "localhost"
    host = ${?POSTGRESQL_ADDON_HOST}
    port = "5432"
    port = ${?POSTGRESQL_ADDON_PORT}
    database = "postgres"
    database = ${?POSTGRESQL_ADDON_DB}
    user = "login"
    user = ${?POSTGRESQL_ADDON_USER}
    pass = "pass"
    pass = ${?POSTGRESQL_ADDON_PASSWORD}
  }
}

Run the application using Clever Cloud CLI 🚀

Create a Clever Cloud application

clever create --type sbt myakka --region par --org testorg

This command creates a new application

• of type sbt for Scala
• named myakka
• in Paris region
• inside my test organisation testorg

Enable a dedicated build instance for faster build (optional pro tip)

By default a newly created application will run an XS instance which are quite small for building Scala applications fast. One way to build faster is to use a dedicated build Instance: In the Clever Cloud console, got to your application -> options, and check the box [] Enable dedicated build instance This way you can keep your XS instance for running the application, but you can choose an XL for the build time. Or with the command line tool:

clever scale -a myakka --build-flavor XL

Create a PostgreSQL database

clever addon -l myakka create postgresql-addon myakkadb

This command orders a PostgreSQL add-on instance and link it to myakka, injecting the right environment variables into the application instance to contact the database.

Database creation and migration is performed using flywaydb tool. Those script may be found in the migration/db directory of the application resources.

Migration will be automatically called once you specify the proper build hook in the environment variables

CC_POST_BUILD_HOOK with value sbt flywayMigrate

clever env -a myakka set CC_POST_BUILD_HOOK "sbt flywayMigrate"

Configure basic auth environment variables

Basic authentication login and password can be specified as environment variables using the clever env command. If none is found, basic authentication will default to application.conf file values

clever env -a myakka set BASIC_AUTH_USER <YOUR_AUTH_USER>
clever env -a myakka set BASIC_AUTH_PASSWORD <YOUR_AUTH_PASSWORD>

Link your local repo with your Clever Cloud application instance

Retrieve your application id with

clever applications

Then link the local repository to the application (creating a .clever.json file)

clever link app_<UUID>

Deploy

You are now ready to deploy and run your code, just run

clever deploy

You are now able to follow the deployment process until it completes successfully

Your application is running now!

Try it

It's time to experiment with it using curl or your favorite GUI

Add a user

Adapt this command in order to insert a new user into the registry:

curl --request POST \
  --url https://app-<UUID>.cleverapps.io/users \
  --header 'Content-type: application/json' \
  -u '<YOUR_AUTH_USER>:<YOUR_AUTH_PASSWORD>' \
  --data '{
  "name": "Serge",
  "age": 42,
  "countryOfResidence": "Greenland"
}'

{
	"description": "User Serge created."
}

Get all users

Check that the user has been properly created, by getting the list of users:

curl --request GET \
  --url https://app-<UUID>.cleverapps.io/users \
  -u '<YOUR_AUTH_USER>:<YOUR_AUTH_PASSWORD>'

{"users":[{"age":42,"countryOfResidence":"Greenland","name":"Serge"}]}

It works, Success! 🎉

00:01:40 – Suicide de Freenode ?
https://www.devever.net/~hl/freenode_suicide
https://isfreenodedeadyet.com/

Letter to freenode – Post Mortem of May 25, 2021
https://freenode.org/news/post-mortem-may21
https://freenode.org/news/taking-irc-further

00:12:00 – How governments and spies text each other
https://www.wired.co.uk/article/matrix-encrypted-messaging-app-governments

Spaces: the next frontier
https://element.io/blog/spaces-the-next-frontier/
https://evolved.systems/hosting-a-blog-on-matrix/
https://cactus.chat/

00:32:06 Huawei investit dans Qwant
https://www.maddyness.com/2021/06/14/huawei-qwant-8-millions-euros/

00:36:13 – Adoption d’IPv6 dans le monde, vu par Google et Akamai:
https://www.google.com/intl/en/ipv6/statistics.html
https://www.akamai.com/fr/fr/resources/our-thinking/state-of-the-internet-report/state-of-the-internet-ipv6-adoption-visualization.jsp

00:39:00 – Tim Berners Lee fait une NFT de son code
https://twitter.com/FinancialTimes/status/1404781711137951746?s=19

00:41:05 – Hack de voiture autonome
https://spqrlab1.github.io/papers/ji-poltergeist-oakland21.pdf
( https://twitter.com/bfmbusiness/status/1390384624866676740 )

00:45:40 – Sortie de Scala 3.0.0
https://github.com/lampepfl/dotty/releases/tag/3.0.0
https://dotty.epfl.ch/
https://docs.scala-lang.org/scala3/guides/migration/compatibility-intro.html

00:55:40 – Grafana 8.0
https://grafana.com/blog/2021/06/08/grafana-8.0-unified-grafana-and-prometheus-alerts-live-streaming-new-visualizations-and-more/
https://grafana.com/blog/2021/06/14/the-new-unified-alerting-system-for-grafana-everything-you-need-to-know/

01:01:40 – Grafana OSS projects, Cortex and Tempo
https://grafana.com/blog/2021/06/10/grafanaconline-day-2-recap-grafana-8-deep-dive-prometheus-innovation-a-billion-time-series-at-robinhood-and-more/
https://grafana.com/blog/2021/06/09/grafana-tempo-is-now-ga-with-the-release-of-v1.0/

01:13:00 – Java 17
https://www.infoworld.com/article/3606833/jdk-17-the-new-features-in-java-17.html#tk.rss_all

01:17:50 – Google utilise du machine learning pour concevoir le routage de ses CPUs
https://www.theverge.com/2021/6/10/22527476/google-machine-learning-chip-design-tpu-floorplanning

01:19:25 – la gate length des transistors n’est plus un bon indicateur pour les comparer
https://www.eejournal.com/article/no-more-nanometers/

01:22:00 – charger une cassette à bande magnétique Acorn ou BBC micro, par WebAudio, et l’exécuter dans le navigateur
https://twitter.com/DominicPajak/status/1404121118017949703?s=19

Le lien musical: “Never Really Get There” par CRi https://www.youtube.com/watch?v=Pfwi1Ervk-8

A few weeks ago I've open sourced issues-helper. It allows you to easily interact with issues on GitHub and GitLab, from the command line.

gli o --assignee clementd --label improvement "Degauss the frobulator fluxfield"

Let's see why and how it's done.

TL;DR

Issues are a good way to keep track of decisions in a project. Opening issues should be easy so people don't forget to write down why they've done things. Opening issues from the command line with minimal fuss is a good thing:

gli init # generate initial configuration
gli o "Issue title" "Optional issue text"
  # add --open to open the issue in the browser once created
  # add --assignee to assign issue
  # add --label to add labels to the issue
gli l # list issues
gli b # open the project homepage in your browser

Issues. Use them.

At Clever Cloud, we use git (and GitLab) a lot. In addition to just using git for code, we also rely a lot on issues. Many discussions end with "please open an issue and sum up what we've just said".

Issues are not just for bugs, we use it as a way to track decisions. Some projects don't even have code and are just there to track discussions and decisions.

My goal, as a CTO, is to make sure we keep track of all of our decisions. So I need people to open issues, to open them often, and to open them early.

Processes. Make 'em easy.

I work with people, not with robots. While I trust them and I know they're good at what they do, I just can't expect them not to make mistakes, or in that case follow processes with no clear incentive. So I needed to remove friction when opening issues. When we interact with code, it's from the command line: we craft commits, we deploy to production, we even close issues from the command line (while crafting commits). So we should also open issues from the terminal.

My first try was to use the ruby gitlab CLI, but it had several issues:

• configuration was done with environment variables
• it's written in ruby and can be complicated to install
• the output is more or less database rows in ascii tables
• you have to specify which project you're talking about

Even though I've written documentation and showed people how to use it, it was not used a lot. When a tool feels like a hack, nobody wants to use it.

What I wanted

I needed two things to get a tool people would use:

• automatically know which project we're talking about
• config files to avoid having to mess with env variables (and leak GitLab tokens)

To avoid ruby installation issues, I've decided to use Rust. There's a lot of available libraries, the build system works well, it's sufficiently expressive to let me express what I want, and in the end I get a nice binary.

XDG basedir. Respect it.

Reading GitLab credentials from a file is not really hard. One common mistake is to put config files directly in ~ like some kind of animal. Instead of cluttering users' home directories, I followed the XDG basedir spec. Most languages have a library which handles it for you, so it really is a no-brainer (and it works out of the box on Windows as well).

Infer information from context

To know where the issues should be opened, issues-helper looks at the origin remote of the current git repo. From that, it knows what to do. Even if you're not currently in the right repo,

j my-project # autojump is great
gli o "My issue" # that's it

Tools. Open Source them.

Once I had this working, not only people started using this tool, but people improved it: @keruspe fixed a lot of issues quite quickly. So the next step was to un-hardcode every Clever Cloud specific things in the codebase (then rebase everything, fun afternoon).

Once it was on GitHub, I got more contributions (from inside and outside). Also, it made me add GitHub support: not being able to use issues-helper to manage its own issues quickly got very frustrating.

Supporting GitHub also made me contribute on the GitHub crate, thus closing a vertuous circle.

There are a few issues left. Feel free to chime in, I'll help you get started. It's a good way to start working on a Rust project!

How it's done

The tool itself doesn't hold a lot of business logic. It parses a project location from a git remote, reads config from a file, sends a few HTTP requests and displays useful information.

CLI arguments parsing

It's one of the most important parts of a program, since it's the UI. The Rust ecosystem has clap which handles everything: parsing, help and even autocompletion.

Unfortunately, the parsed values are exposed through a Map<String,String>, so even though parsing checks structure, you have to recreate the structure yourself. In practice, you end up with a bunch of value.unwrap(); // this should never fail.

Fortunately, there's Structopt, which generates clap config from Rust data structures: all the dirty stuff is handled for you, and you get nice structs and enums. Yay!

Config files

Config is in a toml file, config file location is handled by the xdg crate. Remember: every time you add files to ~, a cute puppy dies.

So

Having processes in a team is a good thing, but if you don't document them, you can't expect people to respect them. If processes don't make everyone's life easier, you can't expect people to respect them. One simple way to make processes stick is to provide tooling to make them the easiest path. A bash script is cool, but mainly for its author. A stable CLI tool with a good UI, written in a robust language is not a lot of work and will age way better.

Post illustration: The Sorcerer's Apprentice, Disney Movies. Friden calculating machine. Credits: Disney

At Clever Cloud we often go to conferences, we answer many CFPs and some of us are even organising conferences from time to time. As such, we understand the amount of work required to manage these.

Just like organizing a conference, managing a CFP can become cumbersome. That's why people started writing new applications from scratch to handle it. Some of them chose Clever Cloud to host them of course. Among those, you will find cfp.io and the Devoxx family.

Some of you asked us if it was possible to run the one used by Devoxx. In this post I will show you how to deploy it on Clever Cloud.

Setup

The application is written in Scala and is based on Play Framework:

Play Framework makes it easy to build web applications with Java & Scala. Play is based on a lightweight, stateless, web-friendly architecture. Built on Akka, Play provides predictable and minimal resource consumption (CPU, memory, threads) for highly-scalable applications.

You will find the code on our good friend Nicolas Martignole's Github account. Take a look at the Readme if you want to run the application locally first. You will see that it needs to write on disk, to store data on Redis, and can optionally benefit from fulltext search with Elastic and accounts on several external services. Don't worry, you don't need everything from the start.

If you want to tag along, make sure you have Git, a Clever Cloud account and that you have installed our CLI Clever-Tools. Let's start:

• Clone the project: git clone https://github.com/nicmarti/cfp-devoxx
• Get in the project: cd cfp-devoxx
• Create the Redis add-on: clever addon create redis-addon --plan s --region eu redisCFP
• Create the FS Bucket add-on: clever addon create fs-bucket --plan s --region eu fsCFP
• Create the application: clever create --type sbt MyCFP
• Link the Redis add-on: clever service link-addon redisCFP
• Link the FS Bucket add-on: clever service link-addon fsCFP
• Define where to mount our FS Bucket: clever env set CC_FS_BUCKET /devoxx-content:`clever env | awk -F = '/BUCKET_HOST/ { print $2}'`
• Remove the old FSBucket configuration: git rm clevercloud/buckets.json && git commit -m"remove old bucket configuration"
• Copy the production configuration sample: cp conf/redis-sample-prod.conf application.conf
• Add your changes and commit them: git add application.conf;git commit -m"add default conf"

We now have to configure the application using environment variables, here is my dummy test configuration:

ACTIVATE_FAVORITES=true
ACTIVATE_GOLDEN_TICKET=false
ACTIVATE_HTTPS=true
ACTIVATE_VOTE=true
APP_SECRET=1f0bc136-5c99-1e6-bee8-60f81dae2bbc
BITBUCKET_PASSWORD=foobar
BITBUCKET_URL=https://bitbucket.org/api/1.0/repositories/foo/bar/issues
BITBUCKET_USERNAME=foobar
BUCKET_ROOTFOLDER=/app
CC_FS_BUCKET=/devoxx-content:bucket-35ca2d97-ff0e-42fb-ba37-abb815fb90a1-fsbucket.services.clever-cloud.com
CFP_HOSTNAME=app_a6dcb49e-1e16-4e06-8f45-dc9e0e838959.cleverapps.io
CFP_IS_OPEN=false
CFP_LANG=en
CRON_DAYS=2
CRON_UPDATER=false
DIGEST_DAILY=08:00
DIGEST_WEEKLY=1
ENABLE_METRICS=true
ES_ADDON_PASSWORD=foobar
ES_ADDON_URI=http://elasticsearch:9200
ES_ADDON_USER=foobar
GITHUB_ID=foobar
GITHUB_SECRET=foobar
GOOGLE_ID=foobar.apps.googleusercontent.com
GOOGLE_SECRET=foobar
JAVA_VERSION=8
LINKEDIN_CLIEND_ID=foobar
LINKEDIN_SECRET=foobar
MAIL_BCC=foobar@devoxx.fr
MAIL_BUG_REPORT=foobar@devoxx.fr
MAIL_COMMITTEE=foobar@devoxx.fr
MAIL_FROM=foobar@devoxx.fr
OPSGENIE_API=TOD
OPSGENIE_NAME=foobar
PORT=8080
SMTP_HOST=in-v3.mailjet.com
SMTP_MOCK=true
SMTP_PASSWORD=foobar
SMTP_PORT=587
SMTP_SSL=false
SMTP_USER=foobar

You can copy/paste this in the Environment variables tab of your application using the Expert Mode. Make sure you set the value of CFP_HOSTNAME to your domain name; Clever Cloud will assign one by default: take a look at the Domain Names tab in our web console to see it or change it (or use clever domain).

And that's it, your configuration is done. The next step is to deploy your application by running clever deploy.

What's next?

Your application should be running now. You can run clever open to make sure it is. It will open it in your default browser.

Now, you can start tweaking the configuration of your application. You can start by looking at all those environment variables if you have not already. There is one point where you will probably ask yourself how to get SMTP crendentials or an Elasticsearch instance from Clever Cloud. While we currently don't have any partnership with e-mails providers, you can ping our support team for the Elastic instance. It's currently in private beta and should soon be open to the public.

If you are looking for more documentation, I invite you to check out the Github repository issues and to give a good look at the production configuration file conf/application.conf.prod. I believe some of them are not mandatory. It would be great to have a documentation update just for the environment variables.

If you are going to use this for your conference, remember to activate autoscaling: clever scale --min-instances 1 --max-instances 2. And if you dread the weekend before your CFP closes, increase the number of minimum instances with clever scale --instances 2.

Post illustration: Computer at her work with microscope and the Friden calculating machine. Credits: NASA

Here at Clever Cloud, we're enthusiastic users of functional programming. It helps us a lot when it comes to have clean and maintainable code.

That's why we were delighted to fly to Bologna for the LambdaCon, to meet the Italian FP community as well as some twitter friends.

After a stop at Yoox offices where Quentin and I got the opportunity to have a chat with developers and the other speakers, it was time for the actual conference.

Fun with Categories

Many interesting functional programming concepts come directly from a branch of mathematics called Category Theory. The keynote speaker Bartosz Milewski went as far as saying that CT is the next revolution after mainstream FP adoption.

I was surprised to witness that "Kleisli Category" frightened people less than the dreaded M-word.

Category Theory is a vast field and can be intimidating for newcomers due to its extremely high level of abstraction, but the good news is that Bartosz is writing an introduction book aimed at developers.

Dissecting the rabbit

Since we use RabbitMQ a lot at Clever Cloud, we were happy to be able to attend Alvaro Videla's talk about RabbitMQ's internals, especially the actor hierarchy in place inside RabbitMQ.

Streams on top of Scala

We're big users of Scala and we deal with a lot of streamed data. That's why we've been using Scala's streaming libraries a lot, first with Play's iteratees, then with scalaz-streams and akka-streams.

Quentin did a nice round-up of what's available and the different use cases for streaming libs in Scala.

The slides are available on slideshare: Streams on top of Scala

TDD as in Type-Directed Development

Even though I've started my career with dynamicallly typed languages, I've been very happy with static, expressive type systems these last years. In this talk I showed how to use types not only for safety, but as a very powerful design and communication tool.

You can have a look at the slides: TDD, as in Type-Directed Development

The european FP community is great

The people from CodersTug did a great job for their first conference. And it's great to see such forward-thinking events take place in Europe.

What’s a pure function?

Getting started with Scala

case class Employee(name: String, title: String, salary: Int)

val employees: List[Employee] = List(
  Employee("Smith", "Junior Developer", 1250),
  Employee("George", "Senior Analyst", 2000),
  Employee("David", "Cadet Developer", 1000),
  Employee("Bernard", "Senior Developer", 2100),
  Employee("Clement", "Senior Developer", 1850)
)

def isSenior(employee: Employee) = employee.title.startsWith("Senior")

val seniorSalaries =
   employees
     .filter(isSenior _)
     .map(_.salary)
     .sum

A new feature for Scala users

+

Simple Built Tool (SBT), the build tool for Scala projects, is now available on Clever Cloud, in open beta. Follow this link to our documentation for more informations.

And also for Java users

We also take the opportunity to make available WAR deployment for Java projects on our PaaS. Clever Cloud provides many WAR containers including Jetty, Tomcat and GlassFish. You can find a table with each of them on our documentation.

Last week review

The new graphs of our console are more beautiful, more complete and in addition they give more informations.

Now, you can check app by app the evolution of your consumption while having a global vision of all your apps.

By the way, we want to come back on the huge success of our website dedicated to Node.JS in the Cloud. As a reminder, this is the first auto-scaling Node.JS PaaS hosting. It was also the opportunity to see the great japaneses community supporting Node.JS!

Version française

Une nouvelle fonctionnalité pour les utilisateurs de Scala

L’outil de build pour les projets Scala, SBT, est maintenant disponible sur Clever Cloud en open beta. Rendez-vous sur la documentation pour plus d’informations.

Et aussi pour les utilisateurs Java

Nous en avons profité pour rendre également disponible le déploiement des projets Java WAR sur notre PaaS. Clever Cloud propose un grand nombre de conteneurs dont Jetty, Tomcat et GlassFish. Vous les retrouverez dans le tableau de notre page de documentation dédiée .

La semaine dernière

Les nouveaux graphs de notre console sont plus jolis, plus complets et en plus ils délivrent plus d’informations (voir photo ci-dessus).

Désormais, il est possible de voir application par application l’évolution de la consommation en drops mais aussi d’obtenir une vision globale de l’ensemble de vos aplications.

Aussi nous souhaitions revenir sur l’énorme succès de notre site dédié à Node.JS sur Clever Cloud.
Rappelons qu’il sagit du premier hébergement cloud Node.JS auto-scalable. Ce fut aussi l’occasion de voir l’importante communauté japonaise soutenant Node.JS.

When interacting with 3rd party json-based APIs from scala, modelling the API's responses with case classes can come in handy. If the JSON exhibits some properties (homogenous lists, for instance), it's easy to create a case class with the same structure. With some deserialization magic it's easier to deal with the API's responses.

So basically is borring to write the case class, and the tool is doing it for you. The target was not to be perfect, but just to allow you quickly generate some case class.

You can test it here : http://json2caseclass.cleverapps.io/

So here is the repo :

Features

json 2 case class can generate

• nested case classes from JSON objects
• lists from JSON arrays
• scala base types from JSON primitives
• Option[T] for optional values

Example

Here is an example with some github issues API data

json from github :

[
  {
    "url": "https://api.github.com/repos/octocat/Hello-World/issues/1347",
    "html_url": "https://github.com/octocat/Hello-World/issues/1347",
    "number": 1347,
    "state": "open",
    "title": "Found a bug",
    "body": "I'm having a problem with this.",
    "user": {
      "login": "octocat",
      "id": 1,
      "avatar_url": "https://github.com/images/error/octocat_happy.gif",
      "gravatar_id": "somehexcode",
      "url": "https://api.github.com/users/octocat"
    },
    "labels": [
      {
        "url": "https://api.github.com/repos/octocat/Hello-World/labels/bug",
        "name": "bug",
        "color": "f29513"
      }
    ],
    "assignee": {
      "login": "octocat",
      "id": 1,
      "avatar_url": "https://github.com/images/error/octocat_happy.gif",
      "gravatar_id": "somehexcode",
      "url": "https://api.github.com/users/octocat"
    },
    "milestone": {
      "url": "https://api.github.com/repos/octocat/Hello-World/milestones/1",
      "number": 1,
      "state": "open",
      "title": "v1.0",
      "description": "",
      "creator": {
        "login": "octocat",
        "id": 1,
        "avatar_url": "https://github.com/images/error/octocat_happy.gif",
        "gravatar_id": "somehexcode",
        "url": "https://api.github.com/users/octocat"
      },
      "open_issues": 4,
      "closed_issues": 8,
      "created_at": "2011-04-10T20:09:31Z",
      "due_on": null
    },
    "comments": 0,
    "pull_request": {
      "html_url": "https://github.com/octocat/Hello-World/issues/1347",
      "diff_url": "https://github.com/octocat/Hello-World/issues/1347.diff",
      "patch_url": "https://github.com/octocat/Hello-World/issues/1347.patch"
    },
    "closed_at": null,
    "created_at": "2011-04-22T13:33:48Z",
    "updated_at": "2011-04-22T13:33:48Z"
  }
]

generated Scala:

case class User(login:String, id:Double, avatar_url:String, gravatar_id:String, url:String)
case class Labels(url:String, name:String, color:String)
case class Milestone(url:String, number:Double, state:String, title:String, description:String, creator:User, open_issues:Double, closed_issues:Double, created_at:String, due_on:String)
case class Pull_request(html_url:String, diff_url:String, patch_url:String)
case class Issue(url:String, html_url:String, number:Double, state:String, title:String, body:String, user:User, labels:List[Labels], assignee:User, milestone:Milestone, comments:Double, pull_request:Option[Pull_request], closed_at:Option[String], created_at:String, updated_at:String)

I hope you'll enjoy it. Feel free to propose new features and/or to contribute !

The Java language was orignally used in complex and costly “enterprise projects”. It was considered hard and tortuous to build simple server-side applications with all of heavy frameworks and tools like Java EE, servlets, application servers and massive IDEs.

But in 2007, a nice project came along: Play!Framework. Easy to build, productivity-oriented and stateless, Play! is one of the most accessible Java framework.
Thus, the success of this new framework emerged, with a growing up community, Play! 2 with Scala, etc.

That’s why we’re thrilled to announce that you can now deploy your existing Play! apps on Clever Cloud, with these features included:

• Auto scalability
• Pay as You Go
• Zero sysadmin and server management
• All Play! versions are supported
• Java and Scala ready.

Please be sure to read carefully our documentation for an effective deployment experience after signing up.