--Originally published at Python learning

Georgina González Enríquez

Sebastián Cedeño González

Web Applications Development Laboratory

Basic 

• Imagine what kind of applications you can do using WebAssembly

Some applications that can be done using WebAssembly are interactive pages for a business or academic entity, game applications, or streaming of content.

• Do you see a future for WebAssembly?

Yes, because since it can be implemented along with web developing languages, it can bring together the advantages of the language WebAssembly is compiling, like C, with the advantages of web languages, like javascript.

Research

• Write a mini-tutorial for using WebAssembly with another language. You must write at least three simple examples. 

Compile and run a hello world program in C

1. Clone precompiled Toolchain repo to compile C to WebAssembly:

$ git clone https://github.com/emscripten-core/emsdk.git

$ cd emsdk

$ ./emsdk install latest

$ ./emsdk activate latest

2. In current command prompt, setup an Emscripten compiler environment (variables and directory entries):

$ source ./emsdk_env.sh –build=Release

3. Create our hello world program in C:

$ mkdir hello

$ cd hello

$ cat << EOF > hello.c

#include <stdio.h>

int main(int argc, char ** argv) {

  printf(“Hello, world!\n”);

}

EOF

4. Compile our program to WebAssembly:

$ emcc hello.c -o hello.html

5. Serve compiled files over HTTP:

$ emrun –no_browser –port 8080 .

6. Open http://localhost:8080/hello.html in your browser. The result should display “Hello, World!”:

Reference: https://webassembly.org/getting-started/developers-guide/

Compile and run a hello world program in C++

Note: since the toolchain used in the previous lesson works also with c++, the steps are almost the same.

1. Clone precompiled Toolchain repo to compile C to WebAssembly

$ git clone https://github.com/emscripten-core/emsdk.git

$ cd emsdk

$ ./emsdk install latest

$ ./emsdk activate latest

2. In current command prompt, setup an Emscripten compiler environment (variables

Continue reading "Laboratory WebAssembly" →

--Originally published at Python learning

Ken’s courses are very different from the traditional way of learning to which I’m used to. The thing is, the teacher doesn’t actually teach in the classroom. Instead, he is a sort of guide in the process, but the student is the one who learns by himself. It sounds kind of harsh, and I must say I was kind of skepticall at first, but now that I have lived through the process, I have a different opinion.

Not all students learn the same; some do it better by reading a book about the topic, others prefer to watch a video tutorial, others need someone to explain it to them, etc. With this teaching method, students can actually choose the way they want to do it, as well as the pace they want to have, which I personally think it’s awesome since some take longer to understand a concept than others, and that’s ok! The teacher, of course, can help you whenever you have a doubt or need a specific explanation. He also gives the topics we need to study (at least!), and hands weekly problems and quizzes for us to know what sort of things we should be able to do.

Something important to take into consideration if you want to dive into this process of learning is that the student has lots of responsability. The teacher is not going to be behind your back all the time making sure you are working, it’s 100% your decision if you want to get it done or not, and when you are going to do it. You need to be very organised, because since there are no due dates until the last day of the semester, you could procrastinate a lot and end up with bad results. That is why so

Continue reading "Course review!" →

--Originally published at Python learning

In several programs I wrote, I imported modules in order to use pre-defined functions to complete a task. For example, you can see I imported math in this one to get a square root, and in this one I imported random.

I read about modules from this page:

https://www.tutorialspoint.com/python/python_modules.htm

You can create your own module by writing a file with the extension .py 

--Originally published at Python learning

*The information of the following paragragh is gotten from this page, check it out to learn more, and the image is gotten from this one, it doesn’t belong to me.

Variables are reserved memory space to store values, which can be integers, decimals or characters. In python you don’t need to declare variables to reserve memory space, it happens automatically when you assign a value to one.

Python data types:

 

--Originally published at Python learning

https://en.wikipedia.org/wiki/Zen_of_Python

Beautiful is better than ugly. (Do things in a pretty way)

Explicit is better than implicit. (Make it so it is understandable for someone else)

Simple is better than complex. (Figure out the easiest solution for a problem)

Complex is better than complicated. (Don’t make it hard)

Flat is better than nested. (Don’t nest unnecessarily)

Sparse is better than dense. (Split the problem into smaller problems)

Readability counts. (Make it easy to read)

Special cases aren’t special enough to break the rules. (Rules matter!)

Although practicality beats purity. (Be practical)

Errors should never pass silently. (Debug)

Unless explicitly silenced. (Unless!)

In the face of ambiguity, refuse the temptation to guess. (Do not assume)

There should be one—and preferably only one—obvious way to do it. (Think simple)

Although that way may not be obvious at first unless you’re Dutch. (Duh)

Now is better than never. (Just do it!)

Although never is often better than right now. (Easter egg)

If the implementation is hard to explain, it’s a bad idea. (Keep it simple!)

If the implementation is easy to explain, it may be a good idea. (Yei!)

Namespaces are one honking great idea—let’s do more of those! (Wuuuuuuu)