Bonjour V!

V is a brand new programming language_ that’s been making quite a few waves in the programming community._

I stumbled upon it a few months back when I read this article.

While V is still in its infancy as of this writing (there are only sixquestions about it on SO), it is gaining popularity (it has around **15.9K **stars on GitHub).

And it’s also under active development (as evidenced by the recent commits in its GitHub repo).

So, I thought, why not give it a try. After all, what’s the harm in being an early adopter, right?

So, let’s get started!

Step 1. Install V on your local machine

You can install V using prebuilt binaries (such as this one), or you can directly compile its source code.

Since I use a MacBook Air (13-inch, 2007) running m_acOS Catalina_ (version 10.15.3), I downloaded this prebuilt binary for macOS.

I extracted its contents and fired up the macOS Terminal_. _Then,I navigated to the directory where I’d extracted the prebuilt binary and fired the following command in the Terminal:

./v version

It’s supposed to display V’s current version, something like below:

V 0.1.24 0d93eeb

But instead, the following prompt popped up on the screen:

https://support.apple.com/en-us/HT202491

You see, macOS blocks the execution of apps that haven’t been notarized_ (meaning, apple can’t verify the origins of the app, and as a result, can’t guarantee that the application isn’t malicious)._

So, what do we do now? Give up?

Absolutely not!

There’s a workaround: We can tell macOS to make an exception for such _unnotarized _apps by navigating to _System Preferences > Security & Privacy _and click the “Allow Anyway” button. Take a peek at the _gif _below to get a better idea:

Now that we’ve told the bouncer (macOS 😀) to let the guest in, we should be able to start the party, right? (run V via the Terminal without any issue)

But no! 😯 That’s not what happens. When we execute the ./v version on the Terminal again, the following screen pops up:

macOS blocks the execution of the app yet again, but this time, there’s an “Open” button, which empowers the user to “run” the app.

This is the same pop-up that we encountered a while back, but this time, macOS has provided us with the “Open” button. Let’s click it and see what happens:

#v-programming-language #new-programming-language #hello-world #coding #programming

What is GEEK

Buddha Community

Bonjour V!

V is a brand new programming language_ that’s been making quite a few waves in the programming community._

I stumbled upon it a few months back when I read this article.

While V is still in its infancy as of this writing (there are only sixquestions about it on SO), it is gaining popularity (it has around **15.9K **stars on GitHub).

And it’s also under active development (as evidenced by the recent commits in its GitHub repo).

So, I thought, why not give it a try. After all, what’s the harm in being an early adopter, right?

So, let’s get started!

Step 1. Install V on your local machine

You can install V using prebuilt binaries (such as this one), or you can directly compile its source code.

Since I use a MacBook Air (13-inch, 2007) running m_acOS Catalina_ (version 10.15.3), I downloaded this prebuilt binary for macOS.

I extracted its contents and fired up the macOS Terminal_. _Then,I navigated to the directory where I’d extracted the prebuilt binary and fired the following command in the Terminal:

./v version

It’s supposed to display V’s current version, something like below:

V 0.1.24 0d93eeb

But instead, the following prompt popped up on the screen:

https://support.apple.com/en-us/HT202491

You see, macOS blocks the execution of apps that haven’t been notarized_ (meaning, apple can’t verify the origins of the app, and as a result, can’t guarantee that the application isn’t malicious)._

So, what do we do now? Give up?

Absolutely not!

There’s a workaround: We can tell macOS to make an exception for such _unnotarized _apps by navigating to _System Preferences > Security & Privacy _and click the “Allow Anyway” button. Take a peek at the _gif _below to get a better idea:

Now that we’ve told the bouncer (macOS 😀) to let the guest in, we should be able to start the party, right? (run V via the Terminal without any issue)

But no! 😯 That’s not what happens. When we execute the ./v version on the Terminal again, the following screen pops up:

macOS blocks the execution of the app yet again, but this time, there’s an “Open” button, which empowers the user to “run” the app.

This is the same pop-up that we encountered a while back, but this time, macOS has provided us with the “Open” button. Let’s click it and see what happens:

#v-programming-language #new-programming-language #hello-world #coding #programming

vlang/v: The V Programming Language

The V Programming Language

---

Key Features of V

• Simplicity: the language can be learned in a weekend
• Fast compilation: ≈110k loc/s with a Clang backend, ≈500k loc/s with native and tcc backends (Intel i5-7500, SSD, no optimization) (demo video)
• Easy to develop: V compiles itself in less than a second
• Performance: as fast as C (V's main backend compiles to human-readable C)
• Safety: no null, no globals, no undefined behavior (wip), immutability by default
• C to V translation (Translating DOOM demo video)
• Hot code reloading
• Flexible memory management. GC by default, manual via v -gc none, arena allocation via v -prealloc, autofree via v -autofree (autofree demo video).
• Cross-platform UI library
• Built-in graphics library
• Easy cross-compilation
• REPL
• Built-in ORM
• Built-in web framework
• C and JavaScript backends
• Great for writing low-level software (Vinix OS)

Stability guarantee and future changes

Despite being at an early development stage, the V language is relatively stable and has backwards compatibility guarantee, meaning that the code you write today is guaranteed to work a month, a year, or five years from now.

There still may be minor syntax changes before the 1.0 release, but they will be handled automatically via vfmt, as has been done in the past.

The V core APIs (primarily the os module) will still have minor changes until they are stabilized in V 1.0. Of course the APIs will grow after that, but without breaking existing code.

Unlike many other languages, V is not going to be always changing, with new features being introduced and old features modified. It is always going to be a small and simple language, very similar to the way it is right now.

Installing V from source

--> (this is the preferred method)

Linux, macOS, Windows, *BSD, Solaris, WSL, etc.

Usually installing V is quite simple if you have an environment that already has a functional git installation.

To get started, simply try to execute the following in your terminal/shell:

git clone https://github.com/vlang/v
cd v
make
# HINT: Using Windows? run make.bat in a cmd shell, or ./make.bat in PowerShell

That should be it and you should find your V executable at [path to V repo]/v. [path to V repo] can be anywhere.

(As in the hint above, on Windows make means running make.bat.)

Now you can try ./v run examples/hello_world.v (or v run examples/hello_world.v in cmd shell).

• Trouble? Please see the note above and link to Installation Issues for help.

V is constantly being updated. To update V, simply run:

v up

Note If you run into any trouble, or you have a different operating system or Linux distribution that doesn't install or work immediately, please see Installation Issues and search for your OS and problem.

If you can't find your problem, please add it to an existing discussion if one exists for your OS, or create a new one if a main discussion doesn't yet exist for your OS.

C compiler

The Tiny C Compiler (tcc) is downloaded for you by make if there is a compatible version for your system, and installed under the V thirdparty directory.

This compiler is very fast, but does almost no optimizations. It is best for development builds.

For production builds (using the -prod option to V), it's recommended to use clang, gcc, or Microsoft Visual C++. If you are doing development, you most likely already have one of those installed.

Otherwise, follow these instructions:

Installing a C compiler on Linux and macOS

Installing a C compiler on Windows

Symlinking

Note It is highly recommended, that you put V on your PATH. That saves you the effort to type in the full path to your v executable every time. V provides a convenience v symlink command to do that more easily.

On Unix systems, it creates a /usr/local/bin/v symlink to your executable. To do that, run:

sudo ./v symlink

On Windows, start a new shell with administrative privileges, for example by pressing the Windows Key, then type cmd.exe, right-click on its menu entry, and choose Run as administrator. In the new administrative shell, cd to the path where you have compiled V, then type:

v symlink

(or ./v symlink in PowerShell)

That will make V available everywhere, by adding it to your PATH. Please restart your shell/editor after that, so that it can pick up the new PATH variable.

Note There is no need to run v symlink more than once - v will still be available, even after v up, restarts, and so on. You only need to run it again if you decide to move the V repo folder somewhere else.

Void Linux

Expand Void Linux instructions

# xbps-install -Su base-devel
# xbps-install libatomic-devel
$ git clone https://github.com/vlang/v
$ cd v
$ make

Docker

Expand Docker instructions

git clone https://github.com/vlang/v
cd v
docker build -t vlang .
docker run --rm -it vlang:latest

Docker with Alpine/musl

git clone https://github.com/vlang/v
cd v
docker build -t vlang --file=Dockerfile.alpine .
docker run --rm -it vlang:latest

Termux/Android

On Termux, V needs some packages preinstalled - a working C compiler, also libexecinfo, libgc and libgc-static. After installing them, you can use the same script, like on Linux/macos:

pkg install clang libexecinfo libgc libgc-static make git
git clone https://github.com/vlang/v
cd v
make

Testing and running the examples

Make sure V can compile itself:

$ v self
$ v
V 0.3.x
Use Ctrl-C or `exit` to exit

>>> println('hello world')
hello world
>>>

cd examples
v hello_world.v && ./hello_world    # or simply
v run hello_world.v                 # this builds the program and runs it right away

v run word_counter/word_counter.v word_counter/cinderella.txt
v run news_fetcher.v
v run tetris/tetris.v

In order to build Tetris or 2048 (or anything else using sokol or gg graphics modules), you will need additional development libraries for your system.

System	Installation method
Debian/Ubuntu based	sudo apt install libxi-dev libxcursor-dev libgl-dev
Fedora/RH/CentOS	sudo dnf install libXcursor-devel libXi-devel libX11-devel libglvnd-devel
NixOS	add xorg.libX11.dev xorg.libXcursor.dev xorg.libXi.dev libGL.dev to environment.systemPackages

V net.http, net.websocket, v install

The net.http module, the net.websocket module, and the v install command may all use SSL. V comes with a version of mbedtls, which should work on all systems. If you find a need to use OpenSSL instead, you will need to make sure that it is installed on your system, then use the -d use_openssl switch when you compile.

To install OpenSSL on non-Windows systems:

System	Installation command
macOS	brew install openssl
Debian/Ubuntu based	sudo apt install libssl-dev
Arch/Manjaro	openssl is installed by default
Fedora/CentOS/RH	sudo dnf install openssl-devel

On Windows, OpenSSL is simply hard to get working correctly. The instructions here may (or may not) help.

V sync

V's sync module and channel implementation uses libatomic. It is most likely already installed on your system, but if not, you can install it, by doing the following:

System	Installation command
macOS	already installed
Debian/Ubuntu based	sudo apt install libatomic1
Fedora/CentOS/RH	sudo dnf install libatomic-static

V UI

 

https://github.com/vlang/ui

Android graphical apps

With V's vab tool, building V UI and graphical apps for Android can become as easy as:

./vab /path/to/v/examples/2048

https://github.com/vlang/vab.

Developing web applications

Check out the Building a simple web blog tutorial and Gitly, a light and fast alternative to GitHub/GitLab:

https://github.com/vlang/gitly

Vinix, an OS/kernel written in V

V is great for writing low-level software like drivers and kernels. Vinix is an OS/kernel that already runs bash, GCC, V, and nano.

https://github.com/vlang/vinix

Acknowledgement

V thanks Fabrice Bellard for his original work on the TCC - Tiny C Compiler. Note the TCC website is old; the current TCC repository can be found here. V utilizes pre-built TCC binaries located at https://github.com/vlang/tccbin/.

Troubleshooting

Please see the Troubleshooting section on our wiki page

---

Download Details:

Author: vlang
Source Code: https://github.com/vlang/v 
License: MIT license

#language #programminglanguage #compiler #v #hacktoberfest 

Bonjour: Share data across devices without a backend.

Recently I found myself trying to achieve something different than what I normally do. I needed to share some information between iOS devices but I didn’t want to develop a backend to be able to achieve it. And so began the search for an alternative.

After a few hours of looking around and thinking that probably Bluetooth might be the obvious solution, I came to a sudden realization:

The iPhones are also connected to my home network, why not take advantage of that?

Sounds straightforward enough. All I need is to figure out how to make the devices see each other and establish communication between them. Easy right? Well, it depends because on paper it sounds pretty painless:

1. Figure out the IP of the device receiving the data.
2. Establish a connection with it.
3. Send data.

Ok, that’s the gist of it if you will. 3 easy simple-sounding steps. However, I don’t know about you but I’ve never worked with network protocols before. Nor have I ever read about how one begins to approach this situation on iOS. Most of the apps I normally use and develop rely on a server to pass information between instances of the app on different devices.

But hey! We have a roadmap we know we need to follow so let’s tackle it one step at a time.

1. Figure out the IP of the device receiving the data

Since the goal is to have the devices talk between each other while being on the same local network, aka my home wifi, I came up with 2 ways to approach this: either by having the IP shown on the one device and manually inputting that value on the sending device or, try to scan the network for all the available devices and pick the correct one from the list.

The first option is simple enough but I feel the user experience would be very subpar. No one should have the need to deal with IP numbers. And the second option while it does take away some of the bad experience from the first it also introduces the problem of having a list of possible devices that could be the receiving one. Yes, you could resolve the hostname and that could help narrow it down, but still, why show more info than needed to the user? Having a list of devices to choose from when you really only need to find the one shouldn’t be the way to go.

There has to be a way that’s user-friendly and developer-friendly. Because scanning a network for devices is not a fun thing to do.

But you know what’s fun? ZeroConf. After narrowing down my new needs my search became more specific I found the existence of this technology. To save you a trip to Wikipedia:

Zero-configuration networking (zeroconf) is a set of technologies that automatically creates a usable computer network based on the Internet Protocol Suite. It does not require manual operator intervention or special configuration servers.

But what’s the difference between this and scanning for devices? You may ask. Well, the main difference is that this is automatic. We don’t need to go an look for all the devices, we just need to look for the devices that want to be found by us and establish the connection.

The concepts behind ZeroConf are complicated enough as it is for me to try to explain them. However, I can try to oversimplify it a bit. Think of ZeroConf as one device using a special sort of Google to get a list of available devices registered to a service with which we can communicate. Well, this sounds more like Tinder than Google… The main point is it allows clients and hosts to be listed and found without much hassle or special configuration.

#zeroconf #bonjour #ios #network #swift

V-If V-Else V-Else-If V-Show In Vue JS

How you can use conditional rendering with the directive v-if, v-else, v-else-if and v-show in vue js. I explain to you step by step these important key features in vue js. After this tutorial you understand how you can use conditional rendering in vue js, to interact better with your template.

❖ Subscribe : https://www.youtube.com/channel/UCVI6tv5boZ62bSsd8k9eM7Q

#vue #vuejs

Node.js (v.14): 2 Things to Know.

Node.js version 14 is here!

As per the official site, Node.js 14 replaces Node.js 13 on 21st April 2020 as a current release.
This article will highlight 2 new JavaScript features included in version 14.
So, Let’s dive deep and check each one.

#node #node.js #v.14