Binary Option Definition - Investopedia

Statically-typed interactive scripting languages?

There seems to be a trend towards adding some sort of gradual typing support to existing dynamically-typed scripting languages (e.g. TypeScript, Hack, Sorbet for Ruby, mypy for Python 3, etc.). I'm wondering if there are any scripting languages that are designed with static typing first (plus type-inference) but allow for some dynamic features like macros? If not, is this even a good idea?
The static type system ideally would be something similar to Swift or Kotlin's, with Optional types instead of Null and tagged unions instead of C-style enums. An escape-hatch for untyped code like TypeScript's Any would be useful for polymorphic functions and metaprogramming. An ML type system is probably too complex for an interactive scripting language but I think ML-style pattern matching would be awesome to have in such a language.
I also think that value semantics and immutability should be the default, like Clojure. Mutability should be opt-in and enforced by the type system (kind of like ref in OCaml). This would help eliminate a whole class of mutability-related bugs in concurrent and parallel programs. A scripting language in 2020 should have great concurrency and thread-safe parallelism support. Since the trend seems to be towards distributed computing, scripts should be easy to deploy to the cloud (preferably as a statically-linked binary).
While Swift and Kotlin are great languages, they don't seem to be designed with interactivity and immutability in mind (Swift seems to be a bit better based on my limited research). They have REPLs, but Swift compile times seem to be a bit too long last time I checked and it feels more like a systems language to me. Languages like Clojure and Common Lisp were designed to be interactive and feel much more like scripting languages suitable for exploratory programming. The only problem with Clojure is that it's too dynamic (Typed Clojure might help but I haven't looked into it much) and the Lisp syntax, while not much of a problem for me personally, prevents it from ever becoming a mainstream language.
The language I'm looking for ideally would have a Python or Ruby-like syntax and a good REPL with support for hot code reloading.
Runtime performance isn't a huge issue for me but ideally the language is faster than Python. Static typing should help a lot with this.
My personal issues with existing languages: - Clojure: (mentioned above) - Common Lisp/Python/Ruby/Julia/Raku (Perl6): mutability is the default - Erlang/Elixir: super dynamic (not sure how well Dialyzer works in practice) - Nim: mutability is the default, systems language - (Am I missing anything?)
Would such a language, if it doesn't exist already, be a good idea in practice? I think the combination of a good static type system with support for dynamic features when needed could make for a really interesting language. I'm open to suggestions.
submitted by krushor to ProgrammingLanguages [link] [comments]

Ethereum on ARM. New Eth2.0 Raspberry Pi 4 image for joining the Medalla multi-client testnet. Step-by-step guide for installing and activating a validator (Prysm, Teku, Lighthouse and Nimbus clients included)

TL;DR: Flash your Raspberry Pi 4, plug in an ethernet cable, connect the SSD disk and power up the device to join the Eth2.0 medalla testnet.
The image takes care of all the necessary steps to join the Eth2.0 Medalla multi-client testnet [1], from setting up the environment and formatting the SSD disk to installing, managing and running the Eth1.0 and Eth2.0 clients.
You will only need to choose an Eth2.0 client, start the beacon chain service and activate / run the validator.
Note: this is an update for our previous Raspberry Pi 4 Eth2 image [2] so some of the instructions are directly taken from there.

MAIN FEATURES

SOFTWARE INCLUDED

INSTALLATION GUIDE AND USAGE

RECOMMENDED HARDWARE AND SETUP
STORAGE
You will need an SSD to run the Ethereum clients (without an SSD drive there’s absolutely no chance of syncing the Ethereum blockchain). There are 2 options:
Use an USB portable SSD disk such as the Samsung T5 Portable SSD.
Use an USB 3.0 External Hard Drive Case with a SSD Disk. In our case we used a Inateck 2.5 Hard Drive Enclosure FE2011. Make sure to buy a case with an UASP compliant chip, particularly, one of these: JMicron (JMS567 or JMS578) or ASMedia (ASM1153E).
In both cases, avoid getting low quality SSD disks as it is a key component of your node and it can drastically affect the performance (and sync times). Keep in mind that you need to plug the disk to an USB 3.0 port (in blue).
IMAGE DOWNLOAD AND INSTALLATION
1.- Download the image:
http://www.ethraspbian.com/downloads/ubuntu-20.04.1-preinstalled-server-arm64+raspi-eth2-medalla.img.zip
SHA256 149cb9b020d1c49fcf75c00449c74c6f38364df1700534b5e87f970080597d87
2.- Flash the image
Insert the microSD in your Desktop / Laptop and download the file.
Note: If you are not comfortable with command line or if you are running Windows, you can use Etcher [10]
Open a terminal and check your MicroSD device name running:
sudo fdisk -l
You should see a device named mmcblk0 or sdd. Unzip and flash the image:
unzip ubuntu-20.04.1-preinstalled-server-arm64+raspi-eth2-medalla.img.zip
sudo dd bs=1M if=ubuntu-20.04.1-preinstalled-server-arm64+raspi.img of=/dev/mmcblk0 conv=fdatasync status=progress
3.- Insert de MicroSD into the Raspberry Pi 4. Connect an Ethernet cable and attach the USB SSD disk (make sure you are using a blue port).
4.- Power on the device
The Ubuntu OS will boot up in less than one minute but you will need to wait approximately 7-8 minutes in order to allow the script to perform the necessary tasks to install the Medalla setup (it will reboot again)
5.- Log in
You can log in through SSH or using the console (if you have a monitor and keyboard attached)
User: ethereum Password: ethereum 
You will be prompted to change the password on first login, so you will need to log in twice.
6.- Forward 30303 port in your router (both UDP and TCP). If you don’t know how to do this, google “port forwarding” followed by your router model. You will need to open additional ports as well depending on the Eth2.0 client you’ve chosen.
7.- Getting console output
You can see what’s happening in the background by typing:
sudo tail -f /valog/syslog
8.- Grafana Dashboards
There are 5 Grafana dashboards available to monitor the Medalla node (see section “Grafana Dashboards” below).

The Medalla Eth2.0 multi-client testnet

Medalla is the official Eth2.0 multi-client testnet according to the latest official specification for Eth2.0, the v0.12.2 [11] release (which is aimed to be the final) [12].
In order to run a Medalla Eth 2.0 node you will need 3 components:
The image takes care of the Eth1.0 setup. So, once flashed (and after a first reboot), Geth (Eth1.0 client) starts to sync the Goerli testnet.
Follow these steps to enable your Eth2.0 Ethereum node:
CREATE THE VALIDATOR KEYS AND MAKE THE DEPOSIT
We need to get 32 Goerli ETH (fake ETH) ir order to make the deposit in the Eth2.0 contract and run the validator. The easiest way of getting ETH is by joining Prysm Discord's channel.
Open Metamask [14], select the Goerli Network (top of the window) and copy your ETH Address. Go to:
https://discord.com/invite/YMVYzv6
And open the “request-goerli-eth” channel (on the left)
Type:
!send $YOUR_ETH_ADDRESS (replace it with the one copied on Metamask)
You will receive enough ETH to run 1 validator.
Now it is time to create your validator keys and the deposit information. For your convenience we’ve packaged the official Eth2 launchpad tool [4]. Go to the EF Eth2.0 launchpad site:
https://medalla.launchpad.ethereum.org/
And click “Get started”
Read and accept all warnings. In the next screen, select 1 validator and go to your Raspberry Pi console. Under the ethereum account run:
cd && deposit --num_validators 1 --chain medalla
Choose your mnemonic language and type a password for keeping your keys safe. Write down your mnemonic password, press any key and type it again as requested.
Now you have 2 Json files under the validator_keys directory. A deposit data file for sending the 32 ETH along with your validator public key to the Eth1 chain (goerli testnet) and a keystore file with your validator keys.
Back to the Launchpad website, check "I am keeping my keys safe and have written down my mnemonic phrase" and click "Continue".
It is time to send the 32 ETH deposit to the Eth1 chain. You need the deposit file (located in your Raspberry Pi). You can, either copy and paste the file content and save it as a new file in your desktop or copy the file from the Raspberry to your desktop through SSH.
1.- Copy and paste: Connected through SSH to your Raspberry Pi, type:
cat validator_keys/deposit_data-$FILE-ID.json (replace $FILE-ID with yours)
Copy the content (the text in square brackets), go back to your desktop, paste it into your favourite editor and save it as a json file.
Or
2.- Ssh: From your desktop, copy the file:
scp [email protected]$YOUR_RASPBERRYPI_IP:/home/ethereum/validator_keys/deposit_data-$FILE_ID.json /tmp
Replace the variables with your data. This will copy the file to your desktop /tmp directory.
Upload the deposit file
Now, back to the Launchpad website, upload the deposit_data file and select Metamask, click continue and check all warnings. Continue and click “Initiate the Transaction”. Confirm the transaction in Metamask and wait for the confirmation (a notification will pop up shortly).
The Beacon Chain (which is connected to the Eth1 chain) will detect this deposit (that includes the validator public key) and the Validator will be enabled.
Congrats!, you just started your validator activation process.
CHOOSE AN ETH2.0 CLIENT
Time to choose your Eth2.0 client. We encourage you to run Lighthouse, Teku or Nimbus as Prysm is the most used client by far and diversity is key to achieve a resilient and healthy Eth2.0 network.
Once you have decided which client to run (as said, try to run one with low network usage), you need to set up the clients and start both, the beacon chain and the validator.
These are the instructions for enabling each client (Remember, choose just one Eth2.0 client out of 4):
LIGHTHOUSE ETH2.0 CLIENT
1.- Port forwarding
You need to open the 9000 port in your router (both UDP and TCP)
2.- Start the beacon chain
Under the ethereum account, run:
sudo systemctl enable lighthouse-beacon
sudo systemctl start lighthouse-beacon
3.- Start de validator
We need to import the validator keys. Run under the ethereum account:
lighthouse account validator import --directory=/home/ethereum/validator_keys
Then, type your previously defined password and run:
sudo systemctl enable lighthouse-validator
sudo systemctl start lighthouse-validator
The Lighthouse beacon chain and validator are now enabled

PRYSM ETH2.0 CLIENT
1.- Port forwarding
You need to open the 13000 and 12000 ports in your router (both UDP and TCP)
2.- Start the beacon chain
Under the ethereum account, run:
sudo systemctl enable prysm-beacon
sudo systemctl start prysm-beacon
3.- Start de validator
We need to import the validator keys. Run under the ethereum account:
validator accounts-v2 import --keys-dir=/home/ethereum/validator_keys
Accept the default wallet path and enter a password for your wallet. Now enter the password previously defined.
Lastly, set up your password and start the client:
echo "$YOUR_PASSWORD" > /home/ethereum/validator_keys/prysm-password.txt
sudo systemctl enable prysm-validator
sudo systemctl start prysm-validator
The Prysm beacon chain and the validator are now enabled.

TEKU ETH2.0 CLIENT
1.- Port forwarding
You need to open the 9151 port (both UDP and TCP)
2.- Start the Beacon Chain and the Validator
Under the Ethereum account, check the name of your keystore file:
ls /home/ethereum/validator_keys/keystore*
Set the keystore file name in the teku config file (replace the $KEYSTORE_FILE variable with the file listed above)
sudo sed -i 's/changeme/$KEYSTORE_FILE/' /etc/ethereum/teku.conf
Set the password previously entered:
echo "yourpassword" > validator_keys/teku-password.txt
Start the beacon chain and the validator:
sudo systemctl enable teku
sudo systemctl start teku
The Teku beacon chain and validator are now enabled.

NIMBUS ETH2.0 CLIENT
1.- Port forwarding
You need to open the 19000 port (both UDP and TCP)
2.- Start the Beacon Chain and the Validator
We need to import the validator keys. Run under the ethereum account:
beacon_node deposits import /home/ethereum/validator_keys --data-dir=/home/ethereum/.nimbus --log-file=/home/ethereum/.nimbus/nimbus.log
Enter the password previously defined and run:
sudo systemctl enable nimbus
sudo systemctl start nimbus
The Nimbus beacon chain and validator are now enabled.

WHAT's NEXT
Now you need to wait for the Eth1 blockchain and the beacon chain to get synced. In a few hours the validator will get enabled and put into a queue. These are the validator status that you will see until its final activation:
Finally, it will get activated and the staking process will start.
Congratulations!, you join the Medalla Eth2.0 multiclient testnet!

Grafana Dashboards

We configured 5 Grafana Dashboards to let users monitor both Eth1.0 and Eth2.0 clients. To access the dashboards just open your browser and type your Raspberry IP followed by the 3000 port:
http://replace_with_your_IP:3000 user: admin passwd: ethereum 
There are 5 dashboards available:
Lots of info here. You can see for example if Geth is in sync by checking (in the Blockchain section) if Headers, Receipts and Blocks fields are aligned or find Eth2.0 chain info.

Updating the software

We will be keeping the Eth2.0 clients updated through Debian packages in order to keep up with the testnet progress. Basically, you need to update the repo and install the packages through the apt command. For instance, in order to update all packages you would run:
sudo apt-get update && sudo apt-get install geth teku nimbus prysm-beacon prysm-validator lighthouse-beacon lighthouse-validator
Please follow us on Twitter in order to get regular updates and install instructions.
https://twitter.com/EthereumOnARM

References

  1. https://github.com/goerli/medalla/tree/mastemedalla
  2. https://www.reddit.com/ethereum/comments/hhvi2ethereum_on_arm_new_eth20_raspberry_pi_4_image/
  3. https://github.com/ethereum/go-ethereum/releases/tag/v1.9.20
  4. https://github.com/ethereum/eth2.0-deposit-cli/releases
  5. https://github.com/prysmaticlabs/prysm/releases/tag/v1.0.0-alpha.23
  6. https://github.com/PegaSysEng/teku
  7. https://github.com/sigp/lighthouse/releases/tag/v0.2.8
  8. https://github.com/status-im/nim-beacon-chain
  9. https://grafana.com
  10. https://www.balena.io/etcher
  11. https://github.com/ethereum/eth2.0-specs/releases/tag/v0.12.2
  12. https://blog.ethereum.org/2020/08/03/eth2-quick-update-no-14
  13. https://goerli.net
  14. https://metamask.io
submitted by diglos76 to ethereum [link] [comments]

After effects crashing on startup

Hey folks I get the below error log when opening after effects. Can't get past it unless I uninstall . any ideas here? Keeps happening

submitted by Lolosdomore to AfterEffects [link] [comments]

MAME 0.222

MAME 0.222

MAME 0.222, the product of our May/June development cycle, is ready today, and it’s a very exciting release. There are lots of bug fixes, including some long-standing issues with classics like Bosconian and Gaplus, and missing pan/zoom effects in games on Seta hardware. Two more Nintendo LCD games are supported: the Panorama Screen version of Popeye, and the two-player Donkey Kong 3 Micro Vs. System. New versions of supported games include a review copy of DonPachi that allows the game to be paused for photography, and a version of the adult Qix game Gals Panic for the Taiwanese market.
Other advancements on the arcade side include audio circuitry emulation for 280-ZZZAP, and protection microcontroller emulation for Kick and Run and Captain Silver.
The GRiD Compass series were possibly the first rugged computers in the clamshell form factor, possibly best known for their use on NASA space shuttle missions in the 1980s. The initial model, the Compass 1101, is now usable in MAME. There are lots of improvements to the Tandy Color Computer drivers in this release, with better cartridge support being a theme. Acorn BBC series drivers now support Solidisk file system ROMs. Writing to IMD floppy images (popular for CP/M computers) is now supported, and a critical bug affecting writes to HFE disk images has been fixed. Software list additions include a collection of CDs for the SGI MIPS workstations.
There are several updates to Apple II emulation this month, including support for several accelerators, a new IWM floppy controller core, and support for using two memory cards simultaneously on the CFFA2. As usual, we’ve added the latest original software dumps and clean cracks to the software lists, including lots of educational titles.
Finally, the memory system has been optimised, yielding performance improvements in all emulated systems, you no longer need to avoid non-ASCII characters in paths when using the chdman tool, and jedutil supports more devices.
There were too many HyperScan RFID cards added to the software list to itemise them all here. You can read about all the updates in the whatsnew.txt file, or get the source and 64-bit Windows binary packages from the download page.

MAME Testers Bugs Fixed

New working machines

New working clones

Machines promoted to working

Clones promoted to working

New machines marked as NOT_WORKING

New clones marked as NOT_WORKING

New working software list additions

Software list items promoted to working

New NOT_WORKING software list additions

submitted by cuavas to emulation [link] [comments]

MAME 0.222

MAME 0.222

MAME 0.222, the product of our May/June development cycle, is ready today, and it’s a very exciting release. There are lots of bug fixes, including some long-standing issues with classics like Bosconian and Gaplus, and missing pan/zoom effects in games on Seta hardware. Two more Nintendo LCD games are supported: the Panorama Screen version of Popeye, and the two-player Donkey Kong 3 Micro Vs. System. New versions of supported games include a review copy of DonPachi that allows the game to be paused for photography, and a version of the adult Qix game Gals Panic for the Taiwanese market.
Other advancements on the arcade side include audio circuitry emulation for 280-ZZZAP, and protection microcontroller emulation for Kick and Run and Captain Silver.
The GRiD Compass series were possibly the first rugged computers in the clamshell form factor, possibly best known for their use on NASA space shuttle missions in the 1980s. The initial model, the Compass 1101, is now usable in MAME. There are lots of improvements to the Tandy Color Computer drivers in this release, with better cartridge support being a theme. Acorn BBC series drivers now support Solidisk file system ROMs. Writing to IMD floppy images (popular for CP/M computers) is now supported, and a critical bug affecting writes to HFE disk images has been fixed. Software list additions include a collection of CDs for the SGI MIPS workstations.
There are several updates to Apple II emulation this month, including support for several accelerators, a new IWM floppy controller core, and support for using two memory cards simultaneously on the CFFA2. As usual, we’ve added the latest original software dumps and clean cracks to the software lists, including lots of educational titles.
Finally, the memory system has been optimised, yielding performance improvements in all emulated systems, you no longer need to avoid non-ASCII characters in paths when using the chdman tool, and jedutil supports more devices.
There were too many HyperScan RFID cards added to the software list to itemise them all here. You can read about all the updates in the whatsnew.txt file, or get the source and 64-bit Windows binary packages from the download page.

MAME Testers Bugs Fixed

New working machines

New working clones

Machines promoted to working

Clones promoted to working

New machines marked as NOT_WORKING

New clones marked as NOT_WORKING

New working software list additions

Software list items promoted to working

New NOT_WORKING software list additions

submitted by cuavas to MAME [link] [comments]

System Programming Language Ideas

I am an embedded electronics guy who has several years of experience in the industry, mainly with writing embedded software in C at the high level and the low level. My goal is to start fresh with some projects in terms of software platforms, so I have been looking at whether to use existing programming languages. I want my electronics / software to be open, but therein lies part of the problem. I have experience using and evaluating many compilers during my experience such as the proprietary stuff (IAR) and open source stuff (clang , gcc, etc.). I have nothing against the open source stuff; however, the companies I have worked for (and I) always come crawling back to IAR. Why? Its not a matter of the compiler believe it or not! Its a matter of the linker.
I took a cursory look at the latest gnu / clang linkers and I do not think that have fixed the major issue we always had with these linkers: memory flood fill. Specifying where each object or section is in the memory is fine for small projects or very small teams (1 to 2 people). However, when you have a bigger team (> 2) and you are using microcontrollers with segmented memory (all memory blocks are not contiguous), memory flood fill becomes a requirement of the linker. Often is the case that the MCUs I and others work on do not have megabytes of memory, but kilobytes. The MCU is chosen for the project and if we are lucky to get one with lots of memory, then you know why such a chip was chosen - there is a large memory requirement in the software.. we would not choose a large memory part if we did not need it due to cost. Imagine a developer is writing a library or piece of code whose memory requirement is going to change by single or tens kilobytes each (added or subtracted) commit. Now imagine having to have this developer manually manage the linker script for their particular dev station each time to make sure the linker doesn't cough based on what everybody else has put it in there. On top of that, they need to manually manage the script if it needs to be changed when they commit and hope that nobody else needed to change it as well for whatever they were developing. For even a small amount of developers, manually managing the script has way too many moving parts to be efficient. Memory flood fill solves this problem. IAR (in addition to a few other linkers like Segger's) allow me to just say: "Here are the ten memory blocks on the device. I have a .text section. You figure out how to spread out all the data across those blocks." No manual script modifications required by each developer for their current dev or requirement to sync at the end when committing. It just works.
Now.. what's the next problem? I don't want to use IAR (or Segger)! Why? If my stuff is going to be open to the public on my repositories.. don't you think it sends the wrong message if I say: "Well, here is the source code everybody! But Oh sorry, you need to get a seat of IAR if you want to build it the way I am or figure out how to build it yourself with your own tool chain". In addition, let's say that we go with Segger's free stuff to get by the linker problem. Well, what if I want to make a sellable product based on the open software? Still need to buy a seat, because Segger only allows non commercial usage of their free stuff. This leaves me with using an open compiler.
To me, memory flood fill for the linker is a requirement. I will not use a C tool chain that does not have this feature. My compiler options are clang, gcc, etc. I can either implement a linker script generator or a linker itself. Since I do not need to support dynamic link libraries or any complicated virtual memory stuff in the linker, I think implementing a linker is easily doable. The linker script generator is the simple option, but its a hack and therefore I would not want to partake in it. Basically before the linker (LD / LLD) is invoked, I would go into all the object files and analyze all of their memory requirements and generate a linker script that implements the flood fill as a pre step. Breaking open ELF files and analyzing them is pretty easy - I have done it in the past. The pre step would have my own linker script format that includes provisions for memory flood fill. Since this is like invoking the linker twice.. its a hack and speed detriment for something that I think should have been a feature of LD / LLD decades ago. "Everybody is using gnu / clang with LD / LLD! Why do you think you need flood fill?" To that I respond with: "People who are using gnu / clang and LD / LLD are either on small teams (embedded) OR they are working with systems that have contiguous memory and don't have to worry about segmented memory. Case and point Phones, Laptops, Desktops, anything with external RAM" Pick one reason. I am sure there are other reasons beyond those two in which segmented memory is not an issue. Maybe the segmented memory blocks are so large that you can ignore most of them for one program - early Visual GDB had this issue.. you would go into the linker scripts to find that for chips like the old NXP 4000 series that they were only choosing a single RAM block for data memory because of the linker limitation. This actually horrendously turned off my company from using gnu / clang at the time. In embedded systems where MCUs are chosen based on cost, the amount of memory is specifically chosen to meet that cost. You can't just "ignore" a memory block due to linker limitations. This would require either to buy a different chip or more expensive chip that meets the memory requirements.
ANYWAYS.. long winded prelude to what has led me to looking at making my own programming language. TLDR: I want my software to be open.. I want people to be able to easily build it without shelling out an arm and a leg, and I am a person who is not fond of hacks because of, what I believe, are oversights in the design of existing software.
Why not use Rust, Nim, Go, Zig, any of those languages? No. Period. No. I work with small embedded systems running with small memory microcontrollers as well as a massive number of other companies / developers. Small embedded systems are what make most of the world turn. I want a systems programming language that is as simple as C with certain modern developer "niceties". This does not mean adding the kitchen sink.. generics, closures, classes ................ 50 other things because the rest of the software industry has been using these for years on higher level languages. It is my opinion that the reason that nothing has (or will) displace C in the past, present, or near future is because C is stupid simple. Its basically structures, functions, and pointers... that's it! Does it have its problems? Sure! However, at the end of the day developers can pick up a C program and go without a huge hassle. Why can't we have a language that sticks to this small subset or "core" functionality instead of trying to add the kitchen sink with all these features of other languages? Just give me my functions and structures, and iterate on that. Let's fix some of the developer productivity issues while we are at it.. and no I don't mean by adding generics and classes. I mean more of getting rid of header files and allowing CTFE. "D is what you want." No.. no it's not. That is a prime example of kitchen sink and the kitchen sink of 50 large corporations across the the block.
What are the problems I think need to be solved in a C replacement?
  1. Header files.
  2. Implementation hiding. Don't know the size of that structure without having to manually manage the size of that structure in a header or exposing all the fields of that structure in a header. Every change of the library containing that structure causes a recompile all the way up the chain on all dependencies.
  3. CTFE (compile time function execution). I want to be able to assign type safe constants to things on initialization.
  4. Pointers replaced with references? I am on the fence with this one. I love the power of pointers, but I realize after research where the industry is trying to go.
These are the things I think that need to be solved. Make my life easier as a developer, but also give me something as stupid simple as C.
I have some ideas of how to solve some of these problems. Disclaimer: some things may be hypocritical based on the prelude discussion; however, as often is the case, not 'every' discussion point is black and white.

  1. Header Files
Replace with a module / package system. There exists a project folder wherein there lies a .build script. The compiler runs the build script and builds the project. Building is part of the language / compiler, but dependency and versioning is not. People will be on both sides of the camp.. for or against this. However, it appears that most module type languages require specifying all of the input files up front instead of being able to "dumb compile" like C / C++ due to the fact that all source files are "truly" dumbly independent. Such a module build system would be harder to make parallel due to module dependencies; however, in total, required build "computation" (not necessarily time) is less. This is because the compiler knows everything up front that makes a library and doesn't have to spawn a million processes (each taking its own time) for each source file.
  1. Implementation hiding
What if it was possible to make a custom library format for the language? Libraries use this custom format and contain "deferrals" for a lot of things that need to be resolved. During packaging time, the final output stage, link time, whatever you want to call it (the executable output), the build tool resolves all of the deferrals because it now knows all parts of input "source" objects. What this means is that the last stage of the build process will most likely take the longest because it is also the stage that generates the code.
What is a deferral? Libraries are built with type information and IR like code for each of the functions. The IR code is a representation that can be either executed by interpreter (for CTFE) or converted to binary instructions at the last output stage. A deferral is a node within the library that requires to be resolved at the last stage. Think of it like an unresolved symbol but for mostly constants and structures.
Inside my library A I have a structure that has a bunch of fields. Those fields may be public or private. Another library B wants to derive from that structure. It knows the structure type exists and it has these public fields. The library can make usage of those public fields. Now at the link stage the size of the structure and all derivative structures and fields are resolved. A year down the road library A changes to add a private field to the structure. Library B doesn't care as long as the type name of the structure or its public members that it is using are not changed. Pull in the new library into the link stage and everything is resolved at that time.
I am an advocate for just having plain old C structures but having the ability to "derive" sub structures. Structures would act the same exact way as in C. Let's say you have one structure and then in a second structure you put the first field as the "base" field. This is what I want to have the ability to do in a language.. but built in support for it through derivation and implementation hiding. Memory layout would be exactly like in C. The structures are not classes or anything else.
I have an array of I2C ports in a library; however, I have no idea how many I2C ports there should be until link time. What to do!? I define a deferred constant for the size of the array that needs to be resolved at link time. At link time the build file passes the constant into the library. Or it gets passed as a command line argument.
What this also allows me to do is to provide a single library that can be built using any architecture at link time.
  1. CTFE
Having safe type checked ways to define constants or whatever, filled in by the compiler, I think is a very good mechanism. Since all of the code in libraries is some sort of IR, it can be interpreted at link time to fill in all the blanks. The compiler would have a massive emphasis on analyzing which things are constants in the source code and can be filled in at link time.
There would exist "conditional compilation" in that all of the code exists in the library; however, at link time the conditional compilation is evaluated and only the areas that are "true" are included in the final output.
  1. Pointers & References & Type safety
I like pointers, but I can see the industry trend to move away from them in newer languages. Newer languages seem to kneecap them compared to what you can do in C. I have an idea of a potential fix.
Pointers or some way is needed to be able to access hardware registers. What if the language had support for references and pointers, but pointers are limited to constants that are filled in by the build system? For example, I know hardware registers A, B, and C are at these locations (maybe filled in by CTFE) so I can declare them as constants. Their values can never be changed at runtime; however, what a pointer does is indicate to the compiler to access a piece of memory using indirection.
There would be no way to convert a pointer to a reference or vise versa. There is no way to assign a pointer to a different value or have it point anything that exists (variables, byte arrays, etc..). Then how do we perform a UART write with a block of data? I said there would be no way to convert a reference ( a byte array for example) to a pointer, but I did not say you could not take the address of a reference! I can take the address of a reference (which points to a block of variable memory) and convert to it to an integer. You can perform any math you want with that integer but you can't actually convert that integer back into a reference! As far as the compiler is concerned, the address of a reference is just integer data. Now I can pass that integer into a module that contains a pointer and write data to memory using indirection.
As far as the compiler is concerned, pointers are just a way to tell the compiler to indirectly read and write memory. It would treat pointers as a way to read and write integer data to memory by using indirection. There exists no mechanism to convert a pointer to a reference. Since pointers are essentially constants, and we have deferrals and CTFE, the compiler knows what all those pointers are and where they point to. Therefore it can assure that no variables are ever in a "pointed to range". Additionally, for functions that use pointers - let's say I have a block of memory where you write to each 1K boundary and it acts as a FIFO - the compiler could check to make sure you are not performing any funny business by trying to write outside a range of memory.
What are references? References are variables that consist of say 8 bytes of data. The first 4 bytes are an address and the next 4 bytes is type information. There exists a reference type (any) that be used for assigning any type to it (think void*). The compiler will determine if casts are safe via the type information and for casts it can't determine at build time, it will insert code to check the cast using the type information.
Functions would take parameters as ByVal or ByRef. For example DoSomething(ByRef ref uint8 val, uint8 val2, uint8[] arr). The first parameter is passing by reference a reference to a uint8 (think double pointer). Assigning to val assigns to the reference. The second parameter is passed by value. The third parameter (array type) is passed by reference implicitly.
  1. Other Notes
This is not an exhaustive list of all features I am thinking of. For example visibility modifiers - public, private, module for variables, constants, and functions. Additionally, things could have attributes like in C# to tell the compiler what to do with a function or structure. For example, a structure or field could have a volatile attribute.
I want integration into the language for inline assembly for the architecture. So you could place a function attribute like [Assembly(armv7)]. This could tell the compiler that the function is all armv7 assembly and the compiler will verify it. Having assembly integrated also allows all the language features to be available to the assembly like constants. Does this go against having an IR representation of the library? No. functions have weak or strong linkage. Additionally, there could be a function attribute to tell the compiler: "Hey when the link stage is using an armv7 target, build this function in". There could also be a mechanism for inline assembly and intrinsics.
Please keep in mind that my hope is not to see another C systems language for larger systems (desktop, phones, laptops, etc.) Its solely to see it for small embedded systems and microcontrollers. I think this is why many of the newer languages (Go, Nim, Zig, etc..) have not been adopted in embedded - they started large and certain things were tacked on to "maybe" support smaller devices. I also don't want to have a runtime with my embedded microcontroller; however, I am not averse to the compiler putting bounds checks and casting checks into the assembly when it needs to. For example, if a cast fails, the compiler could just trap in a "hook" defined by the user that includes the module and line number of where the cast failed. It doesn't even matter that the system hangs or locks up as long as I know where to look to fix the bug. I can't tell you how many times something like this would be invaluable for debugging. In embedded, many of us say that its better for the system to crash hard than limp along because of an array out of bounds or whatever. Maybe it would be possible to restart the system in the event of such a crash or do "something" (like for a cruise missile :)).
This is intended to be a discussion and not so much a religious war or to state I am doing this or that. I just wanted to "blurt out" some stuff I have had on my mind for awhile.
submitted by LostTime77 to ProgrammingLanguages [link] [comments]

MAME 0.222

MAME 0.222

MAME 0.222, the product of our May/June development cycle, is ready today, and it’s a very exciting release. There are lots of bug fixes, including some long-standing issues with classics like Bosconian and Gaplus, and missing pan/zoom effects in games on Seta hardware. Two more Nintendo LCD games are supported: the Panorama Screen version of Popeye, and the two-player Donkey Kong 3 Micro Vs. System. New versions of supported games include a review copy of DonPachi that allows the game to be paused for photography, and a version of the adult Qix game Gals Panic for the Taiwanese market.
Other advancements on the arcade side include audio circuitry emulation for 280-ZZZAP, and protection microcontroller emulation for Kick and Run and Captain Silver.
The GRiD Compass series were possibly the first rugged computers in the clamshell form factor, possibly best known for their use on NASA space shuttle missions in the 1980s. The initial model, the Compass 1101, is now usable in MAME. There are lots of improvements to the Tandy Color Computer drivers in this release, with better cartridge support being a theme. Acorn BBC series drivers now support Solidisk file system ROMs. Writing to IMD floppy images (popular for CP/M computers) is now supported, and a critical bug affecting writes to HFE disk images has been fixed. Software list additions include a collection of CDs for the SGI MIPS workstations.
There are several updates to Apple II emulation this month, including support for several accelerators, a new IWM floppy controller core, and support for using two memory cards simultaneously on the CFFA2. As usual, we’ve added the latest original software dumps and clean cracks to the software lists, including lots of educational titles.
Finally, the memory system has been optimised, yielding performance improvements in all emulated systems, you no longer need to avoid non-ASCII characters in paths when using the chdman tool, and jedutil supports more devices.
There were too many HyperScan RFID cards added to the software list to itemise them all here. You can read about all the updates in the whatsnew.txt file, or get the source and 64-bit Windows binary packages from the download page.

MAME Testers Bugs Fixed

New working machines

New working clones

Machines promoted to working

Clones promoted to working

New machines marked as NOT_WORKING

New clones marked as NOT_WORKING

New working software list additions

Software list items promoted to working

New NOT_WORKING software list additions

submitted by cuavas to cade [link] [comments]

Binary option - YouTube 2 Minutes Strategy Binary Options 2020 (IQ Options) - YouTube Team Alliance YouTube Friday Night LIVE ( Volume 201 )  #TeamAlliance WH Questions မ်ားကုိ Active&Passive ေရးနည္း THE TRUTH ABOUT BINARY OPTIONS - YouTube Геометр  Тригонометр I'm New to Trading Binary Options, Where Do I Start? - YouTube Binary options trading  Binary options signals - YouTube

Binary options allow you to trade on a wide range of underlying markets. One of the advantages of trading binary options is that you are not buying or selling an actual asset, only a contract that determines how that asset performs over a period of time. This limits your risk and makes it easy for anyone to start trading. Available markets. Forex. Major pairs, minor pairs, and Smart FX indices ... nim c --dynlibOverride:lua --passL:liblua.lib program.nim Backend Language Options. The typical compiler usage involves using the compile or c command to transform a .nim file into one or more .c files which are then compiled with the platform's C compiler into a static binary. However there are other commands to compile to C++, Objective-C or ... Binary Options und Bonus. Einige wenige Anbieter von binary Options gewähren einen Bonus auf die Ersteinzahlung, allerdings sind die Bonusbedingungen teilweise nur schwer oder gar nicht erfüllbar. Ein Bonus macht es Einsteigern teilweise jedoch noch einfacher. Unser Test hat jedoch auch gezeigt, dass die Anforderungen um in den Genuss eines Bonus zu gelangen, recht verschieden waren. Häufig ... Binary Options Trading : Basics of Profitable Indicators - Eigne dir mithilfe dieses Online-Kurses von Udemy wertvolle Fähigkeiten an Handel mit Binary Option St. Blasien (Baden-Württemberg) Free money trade binary options , nimm es oder lass es + Binary Options vs. Vanilla Options . A vanilla American option gives the holder the right to buy or sell an underlying asset at a specified price on or before the expiration date of the option. A ... Binary options brokers will generally have their trading platform open when the market of the underlying asset is open. So if trading the NYSE, Nasdaq, DOW or S&P, the assets will be open to trade during the same hours as those markets are open. Any moves by the Federal reserve for example, will feed into binary markets immediately, just as you would expect. Forex trading has no central market ...

[index] [321] [24080] [14994] [20963] [22386] [14935] [6241] [2884] [18071] [1275]

Binary option - YouTube

Best Binary Options Strategy 2020 - 2 Minute Strategy LIVE TRAINING! - Duration: 43:42. ... hyun jang nim Recommended for you. 10:42. Sleepover YouTube Movies. 2004 · Comedy; 1:29:29. Language ... Looking to Join IM Mastery Academy? Check out this 5 Minute Presentation Overview going over Binary Options and IM Mastery Academy HFFX Package! Click For Mo... Free practice account: https://www.nadex.com/demo/?CHID=13&QPID=514243624&QPPID=1&ref=YouTube Listen to Gail Mercer the founder of Traders Help Desk, guide y... Are binary options a good idea? If you're thinking about trading binary options, watch this video first. Check out our FREE training for traders https://bi... IQ Options -https://affiliate.iqoption.com/redir/...Please subscribe and leave a like for more videos.Online trading is a very risky investment/profession. It i... Enjoy the videos and music you love, upload original content, and share it all with friends, family, and the world on YouTube. Binary options trading Binary options signals Hi there! I'm Lady Trader and today I'll show you my binary options strategy 2020 that I use in binary tradin... binary options team alliance teamalliance binary.com binary trading binary iq option options trading expert option stock trade day trading analysis iqoption finance profit wall street bitcoin ... hyun jang nim Recommended for you. 10:42. Best Binary Options Strategy 2020 - 2 Minute Strategy LIVE TRAINING! - Duration: 43:42. BLW Online Trading Recommended for you. 43:42 ...

http://binaryoptiontrade.promquedisp.gq