Educational Philosophy and Idea is a prestigious international journal, publishing articles involved with all features of academic philosophy. Although Rousseau never intended these instructional details to be taken actually as a blueprint (he noticed himself as creating and illustrating the essential rules), over the ages there have been attempts to implement them, one being the famous British free school”, A.S. Neill’s Summerhill (cf.

The very nature of philosophy, on the other hand, is basically contested”; what counts as a sound philosophical work within one college of thought, or socio-cultural or tutorial setting, might not be so regarded (and should even be the main focus of derision) in a distinct one.

No one particular person can have mastered work performed by such a range of figures, representing as they do plenty of fairly completely different frameworks or approaches; and relatedly nobody individual stands as emblematic of the whole area of philosophy …

APA gives continuing education schemes for psychologists and other psychological health professionals. Throughout the area of continuous schooling, skilled persevering with schooling is a selected studying exercise generally characterized by the issuance of a certificate or continuing training models (CEU) for the purpose of documenting attendance at a delegated seminar or course of instruction.

Whether or not you’re seeking to advance your career or jumpstart your online business, pursue studying as an end in itself or as a automobile that can assist you make a difference in the lives of others, Penn has a program that can allow you to achieve the knowledge it’s essential get there.

Mission: San Diego Persevering with Schooling commits to scholar success and group enrichment by offering accessible, equitable, and innovative high quality education and help companies to various grownup learners in pursuit of lifelong studying, training, profession development, and pathways to varsity.

CDC PREPARE: …

OLPC France has deployed Samsung Galaxy Tab A 2018 tablets with Sugarizer OS at the Mendela school. For more details, see http://wiki.sugarlabs.org/go/Sugarizer_Saint-Ouen_deployment

腾讯加速器免费版下载-腾讯加速器免费版手机下载-Appfound:《腾讯加速器免费版》帮你免费解决网络延迟、卡顿问题，让你在游戏中获取到更加稳定的游戏对战玩法操作，腾讯加速器免费版帮你解决在游戏中的各种网络问题，可以说是一款非常值得下载使用的手游加速软件，并且操作简单轻松。

Part of a weekly visit by a volunteer technology teacher and OLPC’s CTO.

file

dsd

Download file

dsd

Continue reading →

Continue reading →

This guide will build on the previous three guides, and look at creating a wider variety of useful nix packages.

Nix is built around the concept of derivations. A derivation is simply defined as "a build action". It produces 1 (or maybe more) output paths in the nix store.

Basically, a derivation is a pure function that takes some inputs (dependencies, source code, etc.) and makes some output (binaries, assets, etc.). These outputs are referenceable by their unique nix-store path.

Derivation Examples

It's important to note that literally everything in NixOS is built around derivations:

• Applications? Of course they are derivations.
• Configuration files? In NixOS, they are a derivation that takes the nix configuration and outputs an appropriate config file for the application.
• The system configuration as a whole (/run/current-system)?

sam@vcs ~> ls -lsah /run/current-system
0 lrwxrwxrwx 1 root root 83 Jan 25 13:22 /run/current-system -> /nix/store/wb9fj59cgnjmkndkkngbwxwzj3msqk9c-nixos-system-vcs-17.09.2683.360089b3521

It's a symbolic link to a derivation!

It's derivations all the way down.

If you've followed this series from the beginning, you would have noticed that we've already made some derivations. Our nix-shell scripts are based off having a derivation. When packaging a shell script, we also made a derivation.

I think it is easiest to learn how to make a derivation through examples. Most packaging tasks are vaguely similar to packaging tasks done in the past by other people. So this will be going through example of using w加速器安卓.

w加速器安卓

Making a derivation manually requires fussing with things like processor architecture and having zero standard build-inputs. This is often not necessary. So instead, NixPkgs provides a function function 加速器大全; which handles the common patterns.

The only real requirement to use mkDerivation is that you have some folder of source material. This can be a reference to a local folder, or something fetched from the internet by another nix function. If you have no source, or just 1 file; consider the "trivial builders" covered in w加速器安卓

mkDerivation does most a lot of work automatically. It divides the build up into "phases", all of which include a little bit of default behaviour - although it is usually unintrusive or can be can be overridden. The most important phases are:

1. unpack: unzips, untarz, or copies your source folder to the nix store
2. patch: applies any patches provided in the 鲸鱼加速器 variable
3. configure: runs ./configure if it exists
4. build: runs 加速器大全 if it exists
5. check: skipped by default
6. install: runs 加速器大全
7. fixup: automagically fixes up things that don't jell with the nix store; such as using incorrect interpreter paths
8. installCheck: runs make installcheck if it exists and is enabled

You can see all the phases in the docs. But with a bit of practice from the examples below you'll likely get the feel for how this works quickly.

酸酸乳客户端

Nix makes writing packages really easy; and with NixOps (which we'll learn later) Nix derivations are automagiaclly built and deployed.

First we need to answer the question of how we would build the static site ourself. This is a jekyll site, so you'd run the jekyll command

立马加速器 立马加速器 <nixpkgs> {};

stdenv.mkDerivation {
  name = "example-website-content";

  # fetchFromGitHub is a build support function that fetches a GitHub
  # repository and extracts into a directory; so we can use it
  # fetchFromGithub is actually a derivation itself :)
  src = fetchFromGitHub {
    owner = "jekyll";
    立马加速器 "example";
    18加速器 虫虫助手2021版app下载-虫虫助手2021版v4.2.3官方版免费 ...:2021-5-5 · 虫虫助手2021版事全新版的破解bt等游戏资源免费下载的玩家福利平台。平台包含了各大热门游戏的破解，优惠充值渠道等，让玩家可免费下载体验各类游戏，网游不充值也能得到最大的乐趣等。 虫虫助手2021版说明 在这里您可以挖掘虫虫最新推出的精品游戏哦。;
    sha256 = "1jw35hmgx2gsaj2ad5f9d9ks4yh601wsxwnb17pmb9j02hl3vgdm";
  };
  # the src can also be a local folder, like:
  # src = /home/sam/my-site;

  # This overrides the shell code that is run during the installPhase.
  # By default; this runs `make install`.
  # The install phase will fail if there is no makefile; so it is the
  # best choice to replace with our custom code.
  installPhase = ''
    # Build the site to the $out directory
虫虫助手免费下载|虫虫助手 V4.2.3 安卓最新版 下载 ...-软件下载:2021-9-11 · 虫虫助手是一款为手游玩家设计的精品应用。虫虫助手为玩家提供了最好玩、最热门的游戏，拥有大型游戏、中文游戏等独立板块，可以满足不同年龄段玩家的需求，为手游玩家带来了很多福利。
    ${pkgs.jekyll}/bin/jekyll build --destination $out
  '';
}

Now we can see that this derivation builds the site. If you save it to test.nix, you can trigger a build by running:

> nix-build test.nix
/nix/store/b8wxbwrvxk8dfpyk8mqg8iqhp7j2c9bs-example-website-content

The path printed by nix-build is where $out was in the Nix store. Your path might be a little different; if you are running a different version of NixPkgs, then the build inputs are different.

【虫虫排名加速器官方下载】虫虫排名加速器 1.012-ZOL ...:2021-11-12 · 虫虫排名加速器是一款在搜素引擎里通过用户间相互自动，虫虫排名加速器是由国内著名的虫虫软件开发商辉创软件技术有限公司，最新开发的一款在搜素引擎里，通过用户间相互自动点击已收录的关键词和网址，加速提高排名的联机点击器，软件完全模拟人工手动点击的过程，用浏览器自动真实 ...

> ls /nix/store/b8wxbwrvxk8dfpyk8mqg8iqhp7j2c9bs-example-website-content
2014  about  css  feed.xml  index.html  LICENSE  README.md

海豚加速器app

We can then use that derivation as a webroot in a nginx virtualHost. If you have a server, you could add the following to your NixOS configuration:

let
  content = stdenv.mkDerivation {
  name = "example-website-content";

    ... # code from above snipped
  }
in
  services.nginx.virtualHosts."example.com" = {
    locations = {
      "/" = {
        root = "${content}";
      }
    }
  };

虫虫游游戏助手v100app下载-虫虫游游戏助手下载-Win10游戏:2021-5-9 · 虫虫游戏助手加速手采用先进的编码技术和核心加速算法进行免费WiFi上网加速，通过优化WiFi性能、增强WiFi信号、优化硬件性能、网络带宽、内存占用、电池消耗、DNS配置等核心因素来实现快速上网体验。 软件介绍 本软件能够快速增强手机与WIFI ...

Using the "${content}" expression, we force the derivation to be converted to a string (remembering 加速器大全 is string interpolation syntax). When a derivation is converted to a string in Nix, it becomes the output path in the Nix store.

If you don't have a server handy, we can use the content in this a simple http server script:

鲸鱼加速器
with import <nixpkgs> {};

let
  content = stdenv.mkDerivation {
    name = "example-website-content";

    加速器大全 fetchFromGitHub {
      owner = "jekyll";
      repo = "example";
      rev = "5eb1b902ca3bda6f4b50d4cfcdc7bc0097bac4b7";
      w加速器安卓 虫虫游游戏助手v100app下载-虫虫游游戏助手下载-Win10游戏:2021-5-9 · 虫虫游戏助手加速手采用先进的编码技术和核心加速算法进行免费WiFi上网加速，通过优化WiFi性能、增强WiFi信号、优化硬件性能、网络带宽、内存占用、电池消耗、DNS配置等核心因素来实现快速上网体验。 软件介绍 本软件能够快速增强手机与WIFI ...;
    };

    installPhase = ''
      export JEKYLL_ENV=production
      # The site expects to be served as http://hostname/example/...
      ${pkgs.jekyll}/bin/jekyll build --destination $out/example
    '';
  };
in
let
  serveSite = pkgs.writeShellScriptBin "serveSite" ''
    # -F = do not fork
    # -p = port
    # -r = content root
虫虫助手2021版app下载-虫虫助手2021版v4.2.3官方版免费 ...:2021-5-5 · 虫虫助手2021版事全新版的破解bt等游戏资源免费下载的玩家福利平台。平台包含了各大热门游戏的破解，优惠充值渠道等，让玩家可免费下载体验各类游戏，网游不充值也能得到最大的乐趣等。 虫虫助手2021版说明 在这里您可以挖掘虫虫最新推出的精品游戏哦。
    # See how we reference the content derivation by `${content}`
    ${webfs}/bin/webfsd -F -p 8000 -r ${content}
  '';
in
stdenv.mkDerivation {
  name = "server-environment";
  # Kind of evil shellHook - you don't get a shell you just get my site
  快喵加速器 ''
    ${serveSite}/bin/serveSite
  '';
}

Then run nix-shell server.nix, you'll then start the server and can view the site!

酸酸乳客户端

We've already talked a lot about shell scripts. But sometimes whole apps get built in shell scripts. One such example is emojify, a CLI tool for replacing words with emojis.

We can make a derivation for that. All we need to do is copy the shell script into the PATH, and mark it as executable.

If we were writing the script ourself, we'd need to pay special attention to fixing up dependencies (such as changing /bin/bash to a Nix store path). But mkDerivation has the fixup phase, which does this automatically. The defaults are smart, and in this case it works perfectly.

It is quite simple to write a derivation for a shell script.

with import <nixpkgs> {};

let
  emojify = let
    虫虫加速器是免费 "2.0.0";
  in
    stdenv.mkDerivation {
      name = "emojify-${version}";

      # Using this build support function to fetch it from github
      src = fetchFromGitHub {
        快喵加速器 加速器大全;
        repo = w加速器安卓;
        虫虫加速器是免费
        rev = "${version}";
        # Hashes must be specified so that the build is purely functional
        sha256 = "0zhbfxabgllpq3sy0pj5mm79l24vj1z10kyajc4n39yq8ibhq66j";
      };

      虫虫游游戏助手v100app下载-虫虫游游戏助手下载-Win10游戏:2021-5-9 · 虫虫游戏助手加速手采用先进的编码技术和核心加速算法进行免费WiFi上网加速，通过优化WiFi性能、增强WiFi信号、优化硬件性能、网络带宽、内存占用、电池消耗、DNS配置等核心因素来实现快速上网体验。 软件介绍 本软件能够快速增强手机与WIFI ...
      installPhase = ''
        # Make the output directory
        mkdir -p $out/bin

        # Copy the script there and make it executable
        cp emojify $out/bin/
        chmod +x $out/bin/emojify
      '';
    };
in
stdenv.mkDerivation {
  name = "emojify-environment";
  buildInputs = [ emojify ];
}

And see it in action:

> nix-shell test.nix

[nix-shell:~]$ emojify "Hello world :smile:"
Hello world 😄

酸酸乳客户端

If you've ever read anything about Nix, you might have seen an example of making a derivation for GNU Hello. Something like this:

with import <nixpkgs> {};

let
  # Let's separate the version number so we can update it easily in the future
  version = "2.10";

  # Now define the derivation for the app
  海豚加速器app stdenv.mkDerivation {
    # String interpolation to include the version number in the name
    # Including a version in the name is idiomatic
    name = 18加速器${version}";

    # fetchurl is a build support again; and does some funky stuff to support
    # selecting from a predefined set of mirrors
    src = fetchurl {
      url = "mirror://gnu/hello/hello-${version}.tar";
      加速器大全 "0ssi1wpaf7plaswqqjwigppsg5fyh99vdlb9kzl7c9lng89ndq1i";
    };

    # Will run `make check`
    doCheck = true;
  };
in
# Make an environment for nix-shell
stdenv.mkDerivation {
  name = "hello-environment";
  buildInputs = [ helloApp ];
}

18加速器

> nix-shell test.nix

[nix-shell:~]$ hello
Hello, world!

Ultimately this is a terrible and indirect example. This doesn't explicitly specify anything that the builder will actually run! It really confused me when I was learning Nix.

To understand it, we need to remember the default build phases from stdenv.mkDerivtion. From above, we had a list of the most important phases. If we annotate the defaults with what happens in the case of GNU Hello, things start to make sense:

Since GNU Hello uses Make & ./configure, the defaults work perfectly for us in this case. That is why this GNU Hello example is so short!

Your Packing Future

While it's amazing to use mkDerivation (so much easier than an RPM spec), there are many cases when you should not use mkDerivation. NixPkgs contains many useful build support functions. These are functions that return derivations, but do a bit of the hard work and boilerplate for you. These make it easy to build packages that meet specified criteria.

We've seen a few 立马加速器 today; such as 虫虫加速器是免费 or 18加速器. These just functions that return derivations. In these cases, they return derivations to download and extract the source files.

For example, there is pkgs.python36Packages.buildPythonPackage, which is a super easy way to build a python package.

科学上网完全指南 – - Bloodline's Blog:2021-4-19 · 免费 蓝灯，每月 500M 的免费流量。也可以付费，但是没有 iOS 客户端。特殊时期不可用。 萤火虫，开源且免费。比较慢，特殊时期不稳定，但可用。 付费 ExpressVPN，相当于 vpn 里的顺丰吧，最稳定也最贵。特殊时期也比较稳定。 其他 可以去这里看看。

• 使命召唤手游下载方法 - 知乎:2021-11-13 · 下载虫虫助手APP，然后搜索使命召唤，然后可以在搜索结果里面找到不同地区的使命召唤。中文版的有：进入游戏后可以选择游客登录但由于是外服游戏进入游戏后会出现提示该地区未开放。这时候你可以在虫虫助手里面搜… of the NixPkgs manual. This documents language specific build support functions.
• The 鲸鱼加速器. Many packages you make could be similar to packages that already exist. (Note that packages inside of NixPkgs are written in a bit of a different way to ours; since they can't reference NixPkgs directly. Instead, they are structured as functions. If a package depends on another, it takes the other packages as an argument. For more on this subject; see Nix Pill 13: Callpackage Design Patten)

Up Next

In part 5, we'll learn about functions in the Nix programming language. With the knowledge of functions, we can write go on and write our own 快喵加速器 function!

Follow the series on GitHub

Hero image from 18加速器

• <<

Getting radical realtime transparency in a project can be slow and frustrating, especially in the beginning. Most folks don’t know this, but in order to have public conversations, leaders need to send out a ridiculous number of private messages to get things rolling. In fact, looking at my own inbox history for the past half-decade, I’ve sent anywhere between 2-20 private messages – on average  (not maximum, 鲸鱼加速器) – to get a single public message during the early stages of a project’s “open” life.

You really need to keep poking people in private asking them to put their messages public. It’s thankless and invisible work. It takes a while to build a new cultural habit, and for a while it’s going to seem like you’ll be doing this forever… but trust me, it will come. It’s going to take longer than you want it to, it’s going to take an unexpected route, but keep the faith – it will come.

There are three strategies it’s useful to have up your sleeve for times like this.

Start the conversation in private, then say something like “hey, this is really good, could you resend it to the public list and I’ll reply there?” This is good for starters if folks are new to the “default to open” concept and are reacting with great nervousness. This nervousness stems from wariness that they may not want to go public with some hypothetical future thing – in effect, worrying about a problem that hasn’t happened yet. Going this route allows beginners in radical transparency to look at something they’ve already written and assess the risk for only that specific situation – no unknowns here, no future commitments. After a few times of going “oh, I guess that retroactive transparency was okay!” it’s much easier to ask people to give “open by default” a chance.

Publicly announce that you’ll only respond to things sent to the public list. Reply to private emails with a reminder of this. This only works only if the people you’re trying to persuade are unable to route around you. It’s also a bit of a strongarm tactic, not appropriate for all situations and best used in moderation if at all. But if you’re a project manager, or an instructor, or a senior engineer, or something of the sort, you might be able to get away with it – and boy, folks learn fast this way.

Get others to help you with the nudges-to-public. Those 20 private emails to get a single public email? No reason why you’ve got to be the only one doing it. Train others to become Agents of Transparency as soon as you can, especially if they were once on the other side of the conversation. To begin with, ask them to work specific mailing lists, specific people, or specific conversation threads into the public eye – coach them from behind if needed. After a little while, they’ll be able to do it on their own – then just ask them to keep an eye out in general, and hey presto!

The key thing to keep in mind is that this is an investment. You’re putting resources into something that may not see returns for a little while. But the returns will come, and they’ll be worth it – when a project tips over into living, breathing, and practicing true realtime transparency, the results of the culture shift can be stunningly refreshing.

Keep going.

This guide will build on the previous two guides, and look at creating your first useful derivation (or "package").

This will teach you how to package a shell script.

加速器大全

We can use the function pkgs.writeShellScriptBin from NixPkgs, which handles generating a derivation for us.

This function takes 2 arguments; what name you want the script to have in your PATH, and a string being the contents of the script.

So we could have:

pkgs.writeShellScriptBin "helloWorld" "echo Hello World"

That would create a shell script named "helloWorld", that printed "Hello World".

Let's put that in an environment; so we can use it in 快喵加速器. Write this to test.nix:

with import <nixpkgs> {};

let
  虫虫助手app下载_虫虫助手app安卓版下载_软吧下载:2021-12-20 · 虫虫助手是一款专为游戏玩家们打造的一款应用。为用户带来了海量的精品游戏。各类的内测新游，畅销游戏都可在这找到。致力让喜爱游戏的你能够轻松找到自己喜爱的游戏资源哦。喜欢的就来 …
  myScript = pkgs.writeShellScriptBin 海豚加速器app "echo Hello World";
in
stdenv.mkDerivation rec {
  name = "test-environment";

  # Add the derivation to the PATH
  buildInputs = [ myScript ];
}

We can then enter the 虫虫加速器是免费 and run it:

sam@vcs ~> nix-shell test.nix

[nix-shell:~]$ helloWorld
Hello World

Great! You've successfully made your first package. If you use NixOS, you can modify your system configuration and include it in your environment.systemPackages list. Or you can use it in a nix-shell (like we just did). Or whatever you want! Despite being one line of code, this is a real Nix derivation that we can use.

Referencing other commands in your script

For this example/section; we are going to look at something more complex. Say you want to write a script to find your public IP address. We're basically going to run this command:

curl http://httpbin.org/get | jq --raw-output .origin

But running this requires dependencies; you need curl and jq installed. How do we specify dependencies in Nix?

Well, we could just add them to the build input for the shell:

# DO NOT USE THIS; this is a BAD example
with import <nixpkgs> {};

let
  # This is the WORST way to do dependencies
  # We just specify the derivation the same way as before
  simplePackage = pkgs.writeShellScriptBin 18加速器 ''
    curl http://httpbin.org/get | jq --raw-output .origin
  '';
in
stdenv.mkDerivation rec {
  name = "test-environment";

  # Then we add curl & jq to the list of buildInputs for the shell
  # So curl and jq will be added to the PATH inside the shell
  buildInputs = [ simplePackage pkgs.jq pkgs.curl ];
}

This would work OK; you could go nix-shell then run whatIsMyIp and get your IP.

But it has a problem. The script would work unpredictably. If you took this package, and used it outside of the nix-shell, it wouldn't work - because you didn't have the dependencies. It also pollutes the environment of the end user; as they need to have a compatible version jq and curl in their path.

The more eloquent way to do this is to reference the exact packages in the shell script:

with w加速器安卓 <nixpkgs> {};

let
  # The ${...} is for string interpolation
  # The '' quotes are used for multi-line strings
  simplePackage = pkgs.writeShellScriptBin 虫虫加速器是免费 ''
    ${pkgs.curl}/bin/curl http://httpbin.org/get \
      | ${pkgs.jq}/bin/jq --raw-output .origin
  '';
in
stdenv.mkDerivation rec {
  name = "test-environment";

  buildInputs = [ simplePackage ];
}

Here we reference the dependency package inside the derivation. To understand what this is doing, we need to see what the script is written to disk as. You can do that by running:

sam@vcs ~> nix-shell test.nix

[nix-shell:~]$ cat $(which whatIsMyIp)

Which gives us:

#!/nix/store/hqi64wjn83nw4mnf9a5z9r4vmpl72j3r-bash-4.4-p12/bin/bash
/nix/store/pkc7g36m95jymw3ga2i7pwrykcfs78il-curl-7.57.0-bin/bin/curl http://httpbin.org/get \
  | /nix/store/znqn0z505i0bm1aiz2jaj1ki7z4ck1sv-jq-1.5/bin/jq --raw-output .origin

As we can see, all the binaries referenced in this script are absolute paths, something like /nix/store/...../bin/name. The 鲸鱼加速器 is the path of the derivation's (package's) build output.

Due to the pure and functional of Nix, that path will be the same on every machine that ever runs Nix. Replacing fuzzy references (eg. jq) with definitive and unambiguous ones (/nix/store/...) is a core tenant of Nix; as it means packages come will all their dependencies and don't pollute your environment.

Since it is an absolute path, that script doesn't rely on the PATH environment variable; so the script can be used anywhere.

When you reference the path (like ${pkgs.curl} from above), Nix automatically knows to download the package into the machine whenever your package is downloaded.

Why do we do it like this? Ultimately, the goal of package management is to make consuming software easier. Creating less dependencies on the environment that runs the package makes it easier to use the script.

鲸鱼加速器

# BAD; not very explicit
考虫app最新版下载_考虫app官方最新版下载_18183下载 ...:1 天前 · 考虫app是一款关于学习的软件，针对考生可以制定不同的学习计划，帮助提升学习效果和成绩，而且还有精品课程，名师在线答疑，全方位的指导呵护，帮大家通过考试!快来下载试试看
虫虫加速器是免费 pkgs.writeShellScriptBin 立马加速器 ''
立马加速器
'';

# GOOD: Nix will do the magic for us
goodPackage = pkgs.writeShellScriptBin "something" ''
  ${pkgs.curl}/bin/curl ...
'';

酸酸乳客户端

One of the main lessons from this process is that when you use functions (like pkgs.writeShellScriptBin) to create packages, it is pretty simple. Compare this to a traditional RPM or DEB workflow; where you would have needed to write a long spec file, put the script in a separate file, and fight your way through too much boilerplate.

Luckily; NixPkgs (the standard library of packages) includes a whole raft of functions that make packaging easier for specific needs. Most of these are in the build support folder of the NixPkgs repository. These are defined in the Nix expression language; the same language you are learning to write. For example, the pkgs.writeShellScriptBin function is defined as a ~10 line function.

Some of the more complex build support functions are documented in 18加速器. There is currently documentation for packaging Python, Go, Haskell, Qt, Rust, Perl, Node and many other types of applications.

Some of the more simple build support functions (like pkgs.writeShellScriptBin) are not documented (when I write this). Most of them are self explanatory, and can be found by reading their names in the so called trivial builders file.

Up Next

Derivations 102 - Learning Nix pt 4

Follow the series on GitHub

Hero image from nix-artwork by Eric Sagnes

This is just an idea I had last night for improving the welcome screen UX, if it’s too much work or Dave and Yash don’t like it I understand. However, I may try to code it myself for fun if Yash doesn’t have time. :-)

My fear is that when users start the Edit Fonts activity for the first time they will be be lost and not understand what to do. Some users might not even have a basic understand of what vector drawing is or how a font is made. This welcome screen will at least give the users a basic idea about how to use the activity. Most importantly, this makes the first screen visualy interesting, interactive and fun. Many users may not continue with the activity if the first page is dull and boring.

I’m proposing that the welcome screen have 4 options, represented by icons and text, plus an editable .glyph that reads “Edit Fonts” in the Geo typeface. The Edit-Fonts logotype will be one .glyph file that is only loaded and never saved. see below:

I have added a Geo-Regular.ufo file to the gh-pages repo with a special “editfonts.glyph” logotype:

http://github.com/sugarlabs/edit-fonts-activity/tree/gh-pages/files/fonts/Geo-Regular.ufo

There are two neat things about this approach. First, it uses components we already have, the only work will be laying out the page, which Dave or I can attempt if Yash is too busy. Second, if the user never realizes that the edit fonts logotype is editable, it still functions as a logotype. A similar UX design pattern was used for the start screen of the game Super Mario 64, see below:

Mario 64 easter-egg

Last Saturday (July 9th) Eli and I met up to review the codebase, and the main issue I identified was that Travis was not set up with flake8 to test the codebase was conforming to the pep8 guidelines.

I’d filed Issue #17 for this, back at the start of the project on May 19. Yash had started to develop the [.travis.yml](http://github.com/sugarlabs/edit-fonts-activity/blob/gh-pages/.travis.yml) file to build a .xo bundle but hadn’t complete this just yet, so I commended out most of the code and what remained is very simple:

# this makes travis run a fast Docker container system
海豚加速器app: false
# we use python 2.7
language: python
python:
  - "2.7"
# we need to install flake8 to use it
before_install:
  - "pip install flake8"
虫虫加速器是免费
加速器大全: 
  - "flake8 --statistics --ignore=E402 --exclude=defcon,extractor,fontTools,fontmake,robofab,ufo2ft,ufoLib,snippets ."

You can see there’s a few arguments passed that are pretty simple.

Stastics prints the number of occurences of each error, so you can fix the most common issues across the codebase first.

E402 is about the order of imports, but since we need to import gi to version later imports, we can’t adhere to that rule, so we ignore it.

We also exclude all the third party libraries, and our snippets.

Eli and I worked together on this and I finished it up on Sunday in Pull Request #65

Yash had already set up Travis configuration, at http://travis-ci.org/sugarlabs/edit-fonts-activity, so once this was merged, our button went green:

Finally I added a CONTRIBUTING.md file that explains how to use it.

I’ll get a similar travis set up for the gh-pages branch too.

Perhaps we could also set up a git hook that runs the flake8 command on each commit…