Responsive hover
Hover dotted
1
2
3
4
5
1
2
3
4
5
Hover images
Norwegian Forest Cat
British Shorthair cat
Exotic cat
Siamese cat
Home
Responsive accordion
Responsive tabs
Responsive forms
Responsive table
Responsive filter
Responsive grid
Responsive hover
Responsive preloaders
Responsive menu
Buy full version for 9$
Developed by Stas Melnikov.


Thoughts: A Triumph For Artificial Intelligence
Today was a significant step forward for artificial intelligence with Google’s AlphaGo winning the first of five matches against Lee Se-dol, who ranks second in international titles in the game of Go.
“I don’t regret accepting this challenge,” said Lee. “I am in shock, I admit that, but what’s done is done. I enjoyed this game and look forward to the next. I think I failed on the opening layout so if I do a better job on the opening aspect I think I will be able to increase my probability of winning.” Lee was surprised both by how strong AlphaGo’s opening was, and by some unexpected moves.
Chess was famously ‘conquered’ by AI with IBM’s DeepBlue, but Go has always been elusive because of a list of reasons. Some of these reasons include the huge board size, the large decision trees, and how the game becomes more complex towards the end rather than more simple. But now, it seems that the computer has the advantage.
However, some commentators state that Lee’s playing wasn’t on par with his normal strength and that he had made avoidable mistakes. It would seem that the next few matches will be interesting.


MetaStorm is a web resource designed to analyze metegenomics data using several computational pipelines.
Find Out More Log In Guest Log InMetaStorm is an online tool designed to enhance the user experience for analyzing metagenomics samples. It consists of a set of tools that allow users to personalize the type of analysis using specific reference databases.

Designed to find and annotate longer sequences (scaffolds) within your samples
Pipeline for annontation by using sequence alignment tools.
High flexibility for the sample annotation


Currently, no data is available
0" class="unique-users-card margin-m"
(clickEvent)="onClick($event)" [title]="'Total Users'" [category2]="''" [category3]="''" [category1]="''"
[uniqueUsers]="totalUsers" [description]="totalUsersDescription">
0" class="unique-users-card margin-m" (clickEvent)="onClick($event)"
[title]="'# Hits'" [category2]="''" [category3]="''" [category1]="''" [uniqueUsers]="hits"
[description]="hitsDescription">
0" class="unique-users-card margin-m"
(clickEvent)="onClick($event)" [title]="'Users accessing content'" [category2]="''" [category3]="''"
[category1]="''" [uniqueUsers]="contentUsers" [description]="contentUsersDescription">
0" class="unique-users-card margin-m"
(clickEvent)="onClick($event)" [title]="'# Access to content'" [category2]="''" [category3]="''"
[category1]="''" [uniqueUsers]="contentAccessed" [description]="contentAccessedDescription">
0 ||
contentData?.weeklyNewUsers?.length > 0 ||
contentData?.monthlyNewUsers?.length > 0
" class="graph-card-bar margin-top-m">
How many new users visited on each day?
0">
How many users visited on each day?
0" class="flex flex-center flex-wrapped">
Hourly Usage
How many users visited on each hour?
{{ filter?.filterName }}
0">
How many users accessed the contents on each day?
0">
Users by Regions
This chart displays # of unique users by regions
0">
Users by Dealer
This chart displays # of unique users by dealer
0">
Users by Guild Groups
This chart displays # of unique users by guild groups
0">
Users by Roles
This chart displays # of unique users by roles
0">
Users by Cities
This chart displays # of unique users by city
0">
Users by Countries
This chart displays # of unique users by country
0">
This chart displays # of unique users for each device type
0">
Users by Departments
This chart displays # of unique users by departments
0">
Users by Sub-Departments
This chart displays # of unique users by sub-Department


Peru calls for restoration of peace in Bolivia, transparent elections
LIMA (Reuters) - Peru called on Sunday for the restoration of a “peaceful existence” in Bolivia, hours after Bolivian President Evo Morales resigned following weeks of turmoil over a disputed election.
In the statement, the Peruvian government also called for transparent elections with the aid of the Organization of American States.


Go to Home
Errors in running application depends on the type of language in which is written, i.e. whether is a "safe" language like Java and C# or an "unsafe" language like C and C++. (C and C++ are the focus languages.) "Safe" and "unsafe", in this context, mean how the language handle memory allocation and deallocation. In the case of "safe" languages, memory can be allocated, but they have a garbage collector (GC) that handles the memory deallocation which prevents some incorrect memory access and some application execution problems and even security holes.
"Unsafe" languages can lead to “undefined behavior”, in which “Anything at all can happen; the Standard imposes no requirements. The program may fail to compile, or it may execute incorrectly (either crashing or silently generating incorrect results), or it may fortuitously do exactly what the programmer intended.” as stated in C FAQ.
Basically, memory corruption is what the undefined behavior means. It refers to any issue that affects an application memory. It is one of the most intractable forms of programming error either because the source of the issue and its manifestation might be far apart or because its symptoms appear under unusual conditions.
Memory corruption may happen at least one of the following conditions take place:
In any case an exception is generated and this can cause application to crash. If there is no crash, application enters in an unpredictable behavior. An application may crash because it writes to memory consider invalid by the operating system. In some cases, the writing may be considered valid, but it modifies the application state. Subsequently, the application might try to use the memory incorrectly written and crashes depending on the memory access.
An application may write bad data to the memory owned by other parts of the application, which might not cause the crash. When other part of the application access the bad data written, it changes its state in an unpredictable way which leads to unpredictable and undefined behavior, such as processing wrong instructions, show incorrect data, etc.
There are two common issue that represent the memory corruptions: Stack Corruption and Heap Corruption. Both will be discussed in later posts, but firstly we shall discuss how we can detect and fix memory corruption issues.
Detecting and fixing a memory corruption issue is at minimum difficult. Some occurrences can be so difficult that we may spend too much time looking for a solution.
The first one is the analysis, which consist on collect data, such as application trace, dump files and source code, when available. The tools needed to analyze the dump will be discussed later.
Source code can be followed while the traces and dumps are analyzed. This helps to understand what behavior was expected and was not performed, which function/method was performed before occurring the exception.
Based on the data collected, one can go deeper into the source code, analyzing the behavior expected and what occurred when the issue happened. One can also use a debugger tool and/or instrument the source code to test it again the conditions the application crashed. Unfortunately, lots of those conditions are certainly not easily reproduced. Tools that instrument source code and debugger tools will also be discussed later.
When an application dynamically allocates memory, it can rely on different methods, such as C/C++ runtime heap (using the new
/delete
and malloc
/calloc
/realloc
/free
APIs), the default process heap, or yet application specific heaps (both use heap APIs). Eventually, all reaches the Heap Manager (NTDLL) and then Virtual Memory Manager.
Heap is one form of Windows memory manager, which applications use to allocate and deallocate memory dynamically. Windows Heap has a complex architecture that will not be discussed in much details here. Instead, let’s sum up what happens when allocation and freeing a block of memory.
The Heap manager first consults the front end allocator to see if a free block of memory is available; if it is the heap manager returns it to the caller. Otherwise, the back end allocator’s free lists are consulted and:
If an exact size match is found, flags are updated to indicate that block is busy; the block is then removed from the free list and returned to the caller.
If an exact size match cannot be found, the heap manager checks to see if a larger block can be split into two smaller blocks that satisfy the request allocation size. If it can, the block is split. One block has the flags updated to a busy state and is returned to the caller. The other block has its flags set to a free state and is added to the free list. The original block is also removed from the free list.
If the free lists cannot satisfy the allocation request, the heap manager commits more memory from the heap segment, creates a new block in the committed range (flags are set to busy state), and returns the block to the caller.
The front end allocator is consulted to see if it can handle the free block. If the free block is not handled by the front end allocator, heap manager checks if there are any adjacent free block; if so, it coalesces the blocks into one large block by doing the following:
The adjacent free blocks are removed from the free lists.
The new large block is added to the free list or front end allocator.
The flags flags field for the new large block is updated to indicate it is free.
If no coalescing can be performed, the block is moved into the free list or front end allocator and the flags are updated to a free state.
Front end allocator has two policies on how memory blocks are handle. The first is look aside list (LAL), which is a table of 128 singly linked list. Each singly linked list in the table contains free heap blocks of a specific size starting at 16 bytes plus 8 bytes of metadata used to manage the block. Then, 32 bytes, then 48 bytes, and so on until 1024 bytes, in the last index. The second policy is low fragmentation (LF), which reduces the fragmentation described in LAL. LAL is default in Windows XP and Windows 2003, but the LF is also supported. Windows Vista and later has LF as default.
Back end allocator contains a table of lists commonly referred to as the free list. The free list’s responsibility is to keep track of all the free heap blocks of a specific size.
Accessing uninitialized memory is a common problem in software. Essentially, uninitialized memory refers to a block of memory, either stack variable or a memory that has been successfully allocated but not initialized to a state which is considered valid.
int main(int> argc, char* argv[])
{
//allocate stack variable
size_t size;
//dynamically allocate a memory
// and using the uninitialized size
char* pdata = new char[size];
if (pdata)
{
std::cout << "Data: " << pdata << ", Size: " << size << std::endl;
//do something here with pdata...
delete [] pdata;
}
return 0;
}
The sample above show two possible problems related to uninitialized memory: (1) when the system allocates the size
variable, its memory may contain a value large enough the end up the system memory when pdata
is allocated, because the size
value is unknown; (2) independently on the value of size, when the std::cout
is performed, it is highly likely that it access invalid memory because it may not find the null
character in the pdata
memory, probably crashing the application. When the system allocates memory to pdata
, a pattern is used to fill that new memory and it does not contains a null
character.
Each heap block, as stated earlier, has a metadata, that is used by the heap manager to properly handle that block. If a faulty piece of code overwrites that data, the heap integrity is compromised and the application may crash. This usually occurs when the block size is not respected and data is written beyond the block boundaries - overruns - or before its initial position - underruns.
int main(int argc,char* argv[])
{
char* pdata = new char[100];
if(pdata)
{
//overrun
memset(pdata,0x00,110);
//underrun
memset(&pdata[-10],0x00,100);
}
return 0;
}
Obviously, there is no reason to right such awful code. Let’s see a more realistic sample below, in which the input is saved into a internal memory and something (we don’t care) is done:
int main(int argc, char* argv[])
{
char* pdata = new char[10];
if (pdata && argc > 1)
{
strcpy(pdata, argv[1]);
//do something with pdata...
}
if (pdata)
delete [] pdata;
return 0;
}
In case the first application argument has more than 10 characters, it will certainly modify memory out of its boundaries. This could certainly corrupt the heap and crash the application.
In addition to the crash and/or heap corruption this could also lead to other consequence that is a security hole. Similarly to the stack overrun, a hacker can also inject a piece of code to gain access to the system by using this technic.
This is also a very common source of heap corruption. After being freed, a block is placed in the free list or front end allocation by the heap manager. From that point, it is considered invalid for application use. If the application uses it in any way, the free list will be corrupted and the application may crash.
int main(int argc,char8 argv[])
{
char* pdata = new char[10];
if (pdata)
{
//do something...
delete [] pdata;
//do something more...
if (argc > 1)
{
strcpy(pdata,argv[1]);
}
std::cout << pdata << std::endl;
}
return 0;
}
Whether or not there is an application argument, when the pdata`` is invalid after
delete``` and incorrectly accessed. In both case, the application is reusing/accessing a freed memory and corrupting the heap.
An application frees some structure that it had already freed. In such a case, a subsequent reference can pick up a meaningless pointer, causing a heap segmentation violation. Possibly, the application will not crash but this can leads to unpredictable behavior.
int main(int argc, char* argv[])
{
char* pdata = new char[10];
if (pdata)
{
//do something...
delete [] pdata;
}
delete [] pdata;
return 0;
}
An application calls an unappropriated memory release method to an addresses. For instance, the application allocates a memory array using new[]
but releases it using delete
or allocates a memory using malloc
and releases it using delete
.
int* int_new = new int;
delete [] int_new;
char* char_array = new char [10];
delete char_array;
long* long_malloc = static_cast<long*>(malloc(sizeof(long)));
delete long_malloc;
double* double_new = new double;
free(double_new);
This kind of issue may not lead to a application crash but certainly leads to unpredictable behavior.
Heap Manager keeps a list of active heaps in a process and an application can have heap handles in addition to the default one. Applications that directly accesses the Heap APIs should be take a extra care while deal with the default - taken from GetProcessHeap
API - and possibly internal process heap - created using HeapCreate
API.
Allocating memory using in one heap and freeing it using other may not cause visible issue at the moment, but one the mismatch occurs the heap gets corruption which later causes unpredictable behavior and access violation.
Stack is one of the most common data structure. It is pretty simple data structure that can be equated to a stack of plates or papers, where you push a new on top of it and pop from the top of it. The top is the next to be pushed or popped. In computers, the stack is in fact the lower addresses. One very good clarification about stack is the Eli Bendersky’s blog.
In Windows system, stack is just a block of memory assigned by the operating system to a running thread. Windows systems (32/64-bits) reserves 1MB for each new thread created for the stack. The stack is also used to track the function calls chain, including allocation of local variables and parameter passing. Once a function is called, a new frame is created on the stack and it will grows bigger and bigger as more and more functions are called. The way a function call grows in the stack depends on the CPU architecture (x86, ARM, RISC, PowerPC). The x86, which will be the focus of our discussion, has some calling conventions that directly affect how the data is placed on the stack.
Now, let’s look at the x86 architecture calling convention. This information may be important to understand what a dump file can show. This will also describe the how a stack is filled and the function decoration (how the compiler and linker builds the name of a function). Also, calling conventions is nothing more than a contract between the caller and callee functions. It specifies rules that both must agree.
The most important types of calling conventions are:
cdecl
Or C declaration, originates from the C language and is defined at __cdecl
. Caller function should clear the stack. Parameters will be passed by via stack from right (on the top) to left (on the bottom). Also, the function will be prefixed by ‘_’.
Let’s look at the sample below:
int __cdecl callee(int, int, int);
int __cdecl caller(void)
{
int ret = callee(1, 2, 3);
ret += 5;
return ret;
}
Using the assembly code, the caller will firstly, push the 3 to stack, then 2 and finally 1 before call the callee function:
push $3
push $2
push $1
call _callee
There are also few details about the registers that should be manipulated in that operation, which also depends on the type of the parameter. There are a vast number of sources that you can look for more details about this information.
stdcall
stdcall
is basically used by Win32, with exceptions for variadic functions, and is defined as __stdcall
. Similar to the cdecl
, it uses the stack to pass parameter, also from left to right, but it is no longer reponsible for cleaning up the stack; the called function should clear stack. Function name are decorated with ‘_’ appended by ‘@’ followed by the number of bytes of stack space required.
Back to the callee
sample above:
int __stdcall callee(int, int, int);
Its decorated name would be: _callee@12
, because each int
parameter has 4 bytes.
fastcall
fastcall
, defined as __fastcall
, is quite similar to the stdcall
, except that the first two parameters is passed on ECX
and EDX
registers and the other are passed by stack. The called function is responsible to clear the stack and its decoration is exactly the same as stdcall
.
thiscall
This is default convention for for C++ member functions that do not use variable arguments. The first parameter, which is the this
parameter, is passed in ECX
register, with the remainder passed on the stack as in stdcall
. As stdcall
, the called function is responsible to clear the stack. The function names are decorated by the C++ compiler in an extremely complicated mechanism that encodes the type of each parameter, among other things. This is necessary because C++ permits function overloading, so a complex decoration scheme must be used so that the various overloads have different decorated names. One interesting post about the C++ decorate names is Microsoft C++ Name Mangling Scheme. There are more details in MSDN.
Now that stack is no longer an obscure thing in software processing, let’s start looking some stack issues. The first is the calling conventions mismatch. As introduced earlier, the different types of calling conventions lead to different way the stack is manipulated. Both caller and callee functions must agree with the rules. Let’s suppose there is DLL with one function:
void __stdcall DllProc(int);
Let's suppose the funcion only prints the argument. Let's look an application that dynamically loads the DLL and executes the function:
typedef int (__cdecl *DLLPROC)(int);
void CallProc(DLLPROC pProc, int arg)
{
pProc(arg);
}
int __cdecl main(int argc,char* argv[])
{
HMODULE hMod = LoadLibrary("DLL.dll");
if(mod)
{
DLLPROC pProc = (DLLPROC)GetProcAddress(hMod,"DllProc");
if(pProc)
{
CallProc(pProc,argc);
}
FreeLibrary(hMod);
}
}
The code is can be compiled and linked. Running the application may not cause any issue and there will be an output but would not be the expected one simply because the calling conventions. The main
function will not expect the DLL!DllProc
to cleanup the stack, but it will as defined as __stdcall
. Before the DLL!DllProc
returns, it is responsible to cleanup the stack, which means it will modify the registers accordingly. However, the main function will also perform the same operation because it believes the DLL!DllProc
will not do it due to the fact the function pointer is set as __cdecl
.
This modifies the stack and causes unpredictable issues. In this specific case, it may probably run the DLL!DllProc
again. If this example is run under a debugger, this will show an exception.
Stack overrun, also know as buffer overflow or stack buffer overflow, occurs when a thread indiscriminately overwrites portions of its call stack reserved for other purpose. Examples of this issue are overwriting the return address for a particular frame, overwriting entire frame, exhausting the stack completely. The effects of stack overrun range from crash, unpredictable behavior and even critical security holes.
One common mistake that causes this issue is copying a string to a smaller area. Take the following sample code below:
void foo(char* pdata)
{
char data[10] = {0}; //stack memory
strcpy(data,pdata);
std::cout << data << "\n";
}
int main(int argc, char* argv[])
{
if(argc > 1)
{
//pass first argument to function
foo(argv[1]);
}
return 0;
}
What would happen if the argv[1]
string is bigger than 10 bytes? A crash would occur because the characters beyond the 10th position, characters out of the allocated memory boundaries, would write the stack memory changing its contents, causing this memory to be invalid. If this memory is, for instance, an instruction address, it can certainly redirect the application execution to wrong path. So, the consequence is a security hole. A hacker can inject a piece of code to gain access to the system by using this technic.
Stack overflow usually occurs when too much memory is used on stack, which contains a limited amount of memory, usually 1MB per thread in Windows system and 8MB per thread in Unix-like systems. The memory size available on stack depends on the language used, the machine architecture, multi-threading, and the amount memory available. When an application attempts to allocate more stack memory that available, it typically crashes as a result of the overflow. The two main reason that results in stack overflow are:
high or infinite number of recursion:
int foo()
{
return foo();
}
very large stack variable:
int foo()
{
double very_large_array[1000000];
//do something ...
return 0;
}
There are two basic rules to avoid this issue: (1) be care when doing recursion, always verifying completely the out case there is no infinite recursion or it is called so many times; (2) do not use much stack variable by allocating any large variable or too many variables, which also can starve the stack memory.
Stack underrun errors as less common, but it can occurs when the stack to be read becomes empty.


General disclaimer: The data contained within this database is not endorsed or certified by the creators of the database, the individuals who entered the data or the supporting institutions. There is no 'warranty' of any sort.
NSF disclaimer: Any opinions, findings, and conclusions or recommendations expressed in this material are those of the author(s) and do not necessarily reflect the views of the National Science Foundation.
LBNL disclaimer: General disclaimer
Supporting institutions and collaborations: Karlsruhe Institute of Technology (KIT), Lawrence Berkeley National Laboratory (LBNL), LBNL Low Background Facility (LBF), Southern Methodist University (SMU), Shanghai Jiao Tong University (SJTU).
This work was supported by the National Science Foundation under Grant Number 1242640 and the Assays and Acquisition of Radiopure Materials (AARM) collaboration. This website is generously hosted by Cloudant.
If you want to help develop this code, contribute your data, or use the software in your experiment or institution then please contact us via the github repository.


Do you ever have problems coping mentalling or emotionally with going out on your own? Yes No Can you go out to places you know? Yes No Sometimes Can you go out to places you don't know? Yes No Sometimes Describe the problems you have with going out and give examples if you can. 1500 characters left {% include "../includes/help.html" %} {% endblock %}


Radish
Radish is a Green food. Green foods are safe to eat as a regular part of a diet.
Category Quotes
Guideline related quotes related to Non-Starchy and Green throughout Geoff Bond's publications.
Eat at least 2 3/4 lbs of mixed salad and vegetables per day, consisting of "Green-Green” and “Green” foods. Of these, at least 3/4 lb should be mixed salad. Also include at least 5 cups of “Green-Green” leafy vegetables or 2 1/2 cups of other vegetables per week. ~Paleo in a Nutshell p.102
Additional Quotes
Specific references to Radish throughout Geoff Bond's publications.
It is quite easy really to achieve six servings by eating one big salad every day with all the usual ingredients we think of as salad vegetables: Tomatoes, lettuce, radish, cucumber, mushrooms, onions, and so forth. ~Paleo in a Nutshell p.48
Conforming non-starchy, colored plant foods are foods that are low-glycemic, rich in micronutrients and fiber, and harmless with regard to anti-nutrients and antigens. Broadly, they include most salad foods, such as lettuce, onions, cucumber, radish, and mushrooms, and they also include colored vegetables, such as broccoli, green beans, bell peppers (sweet peppers), and Brussels sprouts. These are considered "Green-Green," "Green," and "Green-Amber." Under "Green-Green," we have separated out the vegetables that have the high concentrations of background micronutrients that our ancient ancestors delighted in. You can have unlimited consumption of these foods, and the ideal is up to two pounds (900 g) per day. ~Paleo in a Nutshell p.62
Not all underground vegetables are starchy. For example, turnip and radish, which both originated in Asia, are non-starchy, as are bulbs such as onion and garlic from Asia and the leek from the Middle East. Corms such as Chinese water chestnut are also non-starchy. Unlike the starchy roots, they mostly get their bulk from another com pound called "inulin." ~Deadly Harvest p.56


Windows Malware Dataset with PE API Calls
Windows Malware Dataset with PE API Calls
Our public malware dataset generated by Cuckoo Sandbox based on Windows OS API calls analysis for cyber security researchers for malware analysis in csv file format for machine learning applications.
Cite The DataSet
If you find those results useful please cite them :
@article{10.7717/peerj-cs.346,
title = {Data augmentation based malware detection using convolutional neural networks},
author = {Catak, Ferhat Ozgur and Ahmed, Javed and Sahinbas, Kevser and Khand, Zahid Hussain},
year = 2021,
month = jan,
keywords = {Convolutional neural networks, Cybersecurity, Image augmentation, Malware analysis},
volume = 7,
pages = {e346},
journal = {PeerJ Computer Science},
issn = {2376-5992},
url = {https://doi.org/10.7717/peerj-cs.346},
doi = {10.7717/peerj-cs.346}
}
Publications
The details of the Mal-API-2019 dataset are published in following the papers:
- [Link] AF. Yazı, FÖ Çatak, E. Gül, Classification of Metamorphic Malware with Deep Learning (LSTM), IEEE Signal Processing and Applications Conference, 2019.
- [Link] Catak, FÖ., Yazi, AF., A Benchmark API Call Dataset for Windows PE Malware Classification, arXiv:1905.01999, 2019.
Introduction
This study seeks to obtain data which will help to address machine learning based malware research gaps. The specific objective of this study is to build a benchmark dataset for Windows operating system API calls of various malware. This is the first study to undertake metamorphic malware to build sequential API calls. It is hoped that this research will contribute to a deeper understanding of how metamorphic malware change their behavior (i.e. API calls) by adding meaningless opcodes with their own dissembler/assembler parts.
Malware Types and System Overall
In our research, we have translated the families produced by each of the software into 8 main malware families: Trojan, Backdoor, Downloader, Worms, Spyware Adware, Dropper, Virus. Table 1 shows the number of malware belonging to malware families in our data set. As you can see in the table, the number of samples of other malware families except AdWare is quite close to each other. There is such a difference because we don’t find too much of malware from the adware malware family.
| Malware Family | Samples | Description |
|---|---|---|
| Spyware | 832 | enables a user to obtain covert information about another’s computer activities by transmitting data covertly from their hard drive. |
| Downloader | 1001 | share the primary functionality of downloading content. |
| Trojan | 1001 | misleads users of its true intent. |
| Worms | 1001 | spreads copies of itself from computer to computer. |
| Adware | 379 | hides on your device and serves you advertisements. |
| Dropper | 891 | surreptitiously carries viruses, back doors and other malicious software so they can be executed on the compromised machine. |
| Virus | 1001 | designed to spread from host to host and has the ability to replicate itself. |
| Backdoor | 1001 | a technique in which a system security mechanism is bypassed undetectably to access a computer or its data. |
Figure shows the general flow of the generation of the malware data set. As shown in the figure, we have obtained the MD5 hash values of the malware we collect from Github. We searched these hash values using the VirusTotal API, and we have obtained the families of these malicious software from the reports of 67 different antivirus software in VirusTotal. We have observed that the malicious software families found in the reports of these 67 different antivirus software in VirusTotal are different.


THE WOMEN
April 27-28, 1964 at Watkins High School
Director - Ruth Tomlinson
Staging - Mary Anne Duncan, Marge Craft
THE CAST
Peggy - Barbara Helen Mullins
Sylvia - Cathy Williams
Edith - Mollie Newton
Mary - Genie Wheeler
Little Mary - Bobbye Wheelis
Crystal - Rosemary Bouchillon
Countess de Lage - Sharon Valentine
Kaye Bender, Edna Bilek, Gayle Bond, Pat Brewer, Sheila Bull,
Sue Coughlin, Clara Coughman, Dell Davis, Marilyn Dillard,
Charlie Earnest, Jane Ellis, Chris Fargason, Nita Faye Ferris,
Irene Fine, Peggy Gatlin, Rae Gordon, Annie Ruth Grim, Ollie Harper,
Ophelia Harrelson, Patty Howard, Martha Hunt,Page Jones,
Frances Keyes, Mary Love, Bobette Matison, Jennette Pacific,
Peggy Powell, Carol Roulette, Anne Sanders, Dell Scoper,
Charlotte Stamps, Betty Stone, Mary Tew, Patty Turner,
Shirley Wesson, Margaret Wilby, Virginia Wilson


Vendor Name:
Insights Learning & Development
Reference Number:
X001130383
Contract Date:
2013-11-12
Description of Work:
0499 Other Professional Services not Elsewhere Specified
Contract Period:
2013-11-12 to 2015-31-03
Delivery Date:
2015-31-03
Original Contract Value:
$113,702.42
Current Contract Value:
$113,702.42
Comments:
This contract was sole-sourced. This contract is a multi-year contract.
Additional Comments:
Training Aids
Former Public Servant in Receipt of a Pension under the Public Service Superannuation Act:
No


Bootstrap starter template
Use this document as a way to quickly start any new project.
All you get is this text and a mostly barebones HTML document.
Use this document as a way to quickly start any new project.
All you get is this text and a mostly barebones HTML document.


Setup Device
MAC Address:
WiFi Network:
Wifi
WiFi Password:
IP Address:
Gateway:
Netmask:
Acess Token:
MQTT Server:
Update Interval:
Pulse Duration
Scan WiFi
Save settings


--- layout: page title: About header-img: "img/about-bg.png" ---
A UT Austin graduate with Consulting, Analytics, and Entrepreneurship experience. Currently, a Business Analyst at a Dallas-based startup and enrolled in The Flatiron School's Online Online Web Developer Program. The dream is to build impactful and elegant technology products.


Note: Since the description of language-specific features and values depends both on the universal guidelines and on the empirical facts of specific treebanks, it may not be fully updated to v2 until the first treebank release in March 2017.
Additional language-specific values for universal features
The following features are included in the universal set, but some values are missing there. It is likely that these values will be included in future versions of the universal set.
Aspect
- u-feat/Aspect
= Freq
: in UD v2 this should be changed toAspect=Iter
, (iterative), which is now a universal feature. Hungarian: üt “hit” – ütöget “hit several times”
Definite
- u-feat/Definite
= 2
: definiteness-like agreement of verbs with a second person object in Hungarian. Hungarian verbs have to be conjugated in harmony with the definiteness of the object, making a difference between a definite object (nézem a filmet “I am watching the film”), an indefinite object (nézek egy filmet “I am watching a film”) and a second person object (nézlek téged “I am watching you”).
Degree
- u-feat/Degree
= Dim
: diminutive (used for nouns e.g. in Dutch: stoeltje, huisje, nippertje)
Tense
- u-feat/Tense
= Aor
: aorist (as opposed toPast
) in Ancient Greek. Note that other languages may have a past tense that they traditionally call aorist but they mark it using the normalPast
value because the other past tenses have their own special values. Bulgarian is an example: Bulgarian aorist is labeledPast
and imperfect past is labeledImp
.
Voice
Voice = Int
: intensive voice/aspect (the PIEL binyan) in Hebrew.
Language-specific features
In addition to the universal set of features, it is desirable to recognize word features that are particular to one language or a small group of related languages. We also include here features that are not language-specific but rather treebank-specific. They encode something that could occur in many languages but only a few treebanks choose to tag it (for example, whether a word is an abbreviation).
These features are not part of the core universal set but if they appear in more than one language, they should be encoded in all the languages identically.
For the universal features, there may be additional language-specific values that are not (yet) defined at the universal level.
Features that have brackets in their name (such as Gender[psor]
) are layered features.
It means that a feature applies more than once to a word, in layers. The layer is indicated in the brackets.
Layered features are clones of existing non-layered universal or language-specific features.
They have their own language-specific documentation that describes what is the meaning of the layer,
how the list of values is modified for the layer (if at all),
and provides layer-specific examples.
The universal features are mostly derived from the Interset Project (Zeman, 2008). Interset contains additional features that have not yet been adopted as universal features. However, they may be used, if necessary, as part of the “language-specific extensions” to the universal features.
There are automatically generated approximate conversion tables from existing tagsets of various languages to the universal part-of-speech tags and universal + language-specific features.
AdpType
- Ancient Greek values: Prep
- Arabic values: Prep
- Czech values: Prep, Voc, Comprep
- Dutch values: Prep, Post, Circ
- Estonian values: Prep, Post
- Latin values: Prep
- Portuguese values: Prep
- Tamil values: Post
- Interset: Prep, Post, Circ, Voc
AdvType
- Interset: Man, Loc, Tim, Deg, Cau, Mod, Sta, Ex, Adadj
ConjType
- Czech values: Oper
- Interset: Comp, Oper
Connegative
- Finnish values: Yes
Derivation
- Finnish values: Minen, Sti, Inen, Lainen, Ja, Ton, Vs, Ttain, Ttaa
Echo
- Interset: Rdp, Ech
Gender[dat]
- Basque values: Masc, Fem
- Interset: Masc, Fem
Gender[erg]
- Basque values: Masc, Fem
- Interset: Masc, Fem
Gender[psor]
- Czech values: Masc, Fem
- Slovenian values: Masc, Fem, Neut
- Interset: Masc, Fem
Hyph
- Czech values: Yes
- Portuguese values: Yes
- Interset: Yes
InfForm
- Finnish values: 1, 2, 3
NameType
- Czech values: Geo, Prs, Giv, Sur, Nat, Com, Pro, Oth
- Estonian values: Nat
- Interset: Geo, Prs, Giv, Sur, Nat, Com, Pro, Oth
NounType
- Interset: Com, Prop, Class
Number[abs]
- Basque values: Sing, Plur
- Interset: Sing, Plur
Number[dat]
- Basque values: Sing, Plur
- Interset: Sing, Plur
Number[erg]
- Basque values: Sing, Plur
- Interset: Sing, Plur
Number[psee]
- Interset: Sing, Plur
Number[psor]
- Czech values: Sing, Plur
- Finnish values: Sing, Plur
- Portuguese values: Sing, Plur
- Slovenian values: Sing, Dual, Plur
- Interset: Sing, Plur
NumForm
- Arabic values: Digit, Word
- Czech values: Digit, Roman, Word
- Estonian values: Digit, Word
- Latin values: Digit
- Slovenian values: Digit, Roman, Word
- Tamil values: Digit
- Interset: Digit, Roman, Word
NumValue
- Arabic values: 1, 2, 3
- Czech values: 1, 2, 3
- Interset: 1, 2, 3
PartForm
- Finnish values: Pres, Past, Agt, Neg
PartType
- Dutch values: Inf, Vbp
- Interset: Mod, Emp, Res, Inf, Vbp
Person[abs]
- Basque values: 1, 2, 3
- Interset: 1, 2, 3
Person[dat]
- Basque values: 1, 2, 3
- Interset: 1, 2, 3
Person[erg]
- Basque values: 1, 2, 3
- Interset: 1, 2, 3
Person[psor]
- Finnish values: 1, 2, 3
- Interset: 1, 2, 3
Polite[abs]
- Note that unlayered Polite is now a universal feature and the values of the layered counterparts should be changed to
Infm
andForm
. - Basque values: Inf, Pol
- Interset: Inf, Pol
Polite[erg]
- Note that unlayered Polite is now a universal feature and the values of the layered counterparts should be changed to
Infm
andForm
. - Basque values: Inf, Pol
- Interset: Inf, Pol
Polite[dat]
- Note that unlayered Polite is now a universal feature and the values of the layered counterparts should be changed to
Infm
andForm
. - Basque values: Inf, Pol
- Interset: Inf, Pol
Prefix
- Interset: Yes
PrepCase
- Czech values: Npr, Pre
- Portuguese values: Pre
- Spanish values: Npr, Pre
- Interset: Npr, Pre
PunctSide
- Dutch values: Ini, Fin
- Interset: Ini, Fin
PunctType
- Dutch values: Brck, Colo, Comm, Excl, Peri, Qest, Quot, Semi
- Estonian values: Comm, Excl, Peri, Qest
- Tamil values: Comm, Peri
- Interset: Peri, Qest, Excl, Quot, Brck, Comm, Colo, Semi, Dash
Style
- Czech values: Arch, Rare, Poet, Norm, Coll, Vrnc, Slng, Expr, Derg, Vulg
- Finnish values: Arch, Coll
- Interset: Arch, Rare, Poet, Norm, Coll, Vrnc, Slng, Expr, Derg, Vulg
Subcat
- Dutch values: Intr, Tran
- Interset: Intr, Tran
Typo
- Finnish values: Yes
- Portuguese values: Yes
- Interset: Yes
Variant
- Czech values: Short
- Dutch values: Short
- Slovenian values: Bound, Short
VerbType
- Dutch values: Aux, Cop, Mod
- Estonian values: Mod
- Italian values: Aux, Cop, Mod
- Latin values: Mod
- Interset: Aux, Cop, Mod, Light


| 976 | (A) | Made wayes thorowe the wallis for waynes and cartis |
| 981 | (C) | And þenne made he wayes þorowȝ þe wałł . for waynes & cartes |
| 963 | (D) | weyes made þurgħ þe wałł for waynes & cartis |
| 944 | (E) | & weyes make þourgħt þe walles . for waynes & cartes |
| 23 | (Ex) | Made wayes thurw . . . |
| 1001 | (L) | Made weys þrow for wenes & cartes |
| 916 | (P) | ??de wayes thurghe þe walles with waynes & kartes |
| 954 | (U) | wayes made thurgħ wal / for weynes and cartes |
| 41 | (V) | And maad weies þrougȝ þe wałł . for waynnes and cartes |


Nathan Hale
`Prev `__
N
`Next `__
--------------
**Nathan Hale**: n.
An asterisk (see also `*splat* <../S/splat.html>`__,
`*ASCII* <../A/ASCII.html>`__). Oh, you want an etymology? Notionally,
from “I regret that I have only one asterisk for my country!”, a
misquote of the famous remark uttered by Nathan Hale just before he was
hanged. Hale was a (failed) spy for the rebels in the American War of
Independence.
--------------
+------------------------------+----------------------------+---------------------------+
| `Prev `__ | `Up <../N.html>`__ | `Next `__ |
+------------------------------+----------------------------+---------------------------+
| nastygram | `Home <../index.html>`__ | nature |
+------------------------------+----------------------------+---------------------------+


My name is Parker Dinkins and I have been playing with computers for over fifteen years. I started getting serious about learning how to code in 2017.
I started by learning HTML and CSS so that I could create websites. I then went on to learn Python which is my favorite language. I learned Javascript in an internet programming class and learned that I really love Python after learning C++ for a Data Structures and Algorithms class.
I consider myself a hacker and a futurist. I love exploring topics like data sovereignty, crypto-currencies and the metaverse. I'm interested in studying how humans interact with technology and how technology interacts with humans. There is a clear two way relationship between technology and people and I hope to shed some light on the subject throughout my lifetime by documenting my journey as I go down the rabbit hole.
reach out and lets talk


Note: this test requires dijit.
Count widgets in registry
A performance test designed to go head to head with DataGrid's test_datagrid_performance.html


The following sample demonstrates how to use the Repeater Control with nested declarative WinJS.Binding.Templates to build a simple nested bar graph using a series of progress
elements. In this example items can be dynamically added and removed from the graph and the nested Repeater controls will automatically update the view. Also the Repeater control can be used with CSS layouts like CSS Flexbox and CSS Grid to have full control over the graph's layout of items.


{-# LANGUAGE CPP #-} {-# LANGUAGE ScopedTypeVariables #-} module System.EasyFile.Directory ( module System.EasyFile.Directory , module System.Directory ) where import System.Directory ( createDirectory , createDirectoryIfMissing , removeDirectory , removeDirectoryRecursive , renameDirectory , getDirectoryContents , setCurrentDirectory , removeFile , renameFile , copyFile , canonicalizePath , doesFileExist , doesDirectoryExist , Permissions(..) , getPermissions , setPermissions ) import qualified System.Directory as D ( getCurrentDirectory , getHomeDirectory , getAppUserDataDirectory , getUserDocumentsDirectory , getTemporaryDirectory , copyPermissions ) import Control.Applicative import qualified Control.Exception as E import System.Environment ---------------------------------------------------------------- {- |If the operating system has a notion of current directories, 'getCurrentDirectory' returns an absolute path to the current directory of the calling process. The operation may fail with: * 'HardwareFault' A physical I\/O error has occurred. @[EIO]@ * 'isDoesNotExistError' \/ 'NoSuchThing' There is no path referring to the current directory. @[EPERM, ENOENT, ESTALE...]@ * 'isPermissionError' \/ 'PermissionDenied' The process has insufficient privileges to perform the operation. @[EACCES]@ * 'ResourceExhausted' Insufficient resources are available to perform the operation. * 'UnsupportedOperation' The operating system has no notion of current directory. -} getCurrentDirectory :: IO FilePath getCurrentDirectory = fixPath <$> D.getCurrentDirectory {- | Returns the current user's home directory. The directory returned is expected to be writable by the current user, but note that it isn't generally considered good practice to store application-specific data here; use 'getAppUserDataDirectory' instead. On Unix, 'getHomeDirectory' returns the value of the @HOME@ environment variable. On Windows, the system is queried for a suitable path; a typical path might be @C:/Documents And<EMAIL_ADDRESS>The operation may fail with: * 'UnsupportedOperation' The operating system has no notion of home directory. * 'isDoesNotExistError' The home directory for the current user does not exist, or cannot be found. -} getHomeDirectory :: IO FilePath getHomeDirectory = fixPath <$> D.getHomeDirectory {- | Returns the current user's home directory from the @HOME@ environment variable. -} getHomeDirectory2 :: IO (Maybe FilePath) getHomeDirectory2 = (Just . fixPath <$> getEnv "HOME") `E.catch` \(_ :: E.IOException) -> return Nothing {- | Returns the pathname of a directory in which application-specific data for the current user can be stored. The result of 'getAppUserDataDirectory' for a given application is specific to the current user. The argument should be the name of the application, which will be used to construct the pathname (so avoid using unusual characters that might result in an invalid pathname). Note: the directory may not actually exist, and may need to be created first. It is expected that the parent directory exists and is writable. On Unix, this function returns<EMAIL_ADDRESS>On Windows, a typical path might be > C:/Documents And Settings/user/Application Data/appName The operation may fail with: * 'UnsupportedOperation' The operating system has no notion of application-specific data directory. * 'isDoesNotExistError' The home directory for the current user does not exist, or cannot be found. -} getAppUserDataDirectory :: String -> IO FilePath getAppUserDataDirectory x = fixPath <$> D.getAppUserDataDirectory x {- | Returns the current user's document directory. The directory returned is expected to be writable by the current user, but note that it isn't generally considered good practice to store application-specific data here; use 'getAppUserDataDirectory' instead. On Unix, 'getUserDocumentsDirectory' returns the value of the @HOME@ environment variable. On Windows, the system is queried for a suitable path; a typical path might be @C:\/Documents and Settings\/user\/My<EMAIL_ADDRESS>The operation may fail with: * 'UnsupportedOperation' The operating system has no notion of document directory. * 'isDoesNotExistError' The document directory for the current user does not exist, or cannot be found. -} getUserDocumentsDirectory :: IO FilePath getUserDocumentsDirectory = fixPath <$> D.getUserDocumentsDirectory {- | Returns the current directory for temporary files. On Unix, 'getTemporaryDirectory' returns the value of the @TMPDIR@ environment variable or \"\/tmp\" if the variable isn\'t defined. On Windows, the function checks for the existence of environment variables in the following order and uses the first path found: * TMP environment variable. * TEMP environment variable. * USERPROFILE environment variable. * The Windows directory The operation may fail with: * 'UnsupportedOperation' The operating system has no notion of temporary directory. The function doesn\'t verify whether the path exists. -} getTemporaryDirectory :: IO FilePath getTemporaryDirectory = fixPath <$> D.getTemporaryDirectory ---------------------------------------------------------------- fixPath :: FilePath -> FilePath #if defined(mingw32_HOST_OS) || defined(__MINGW32__) fixPath [] = [] fixPath (c:cs) | c == '\\' = '/' : fixPath cs | otherwise = c : fixPath cs #else fixPath = id #endif ---------------------------------------------------------------- -- Just adding documentation. {-| This function copy the permission of the first file to the second. -} copyPermissions :: FilePath -> FilePath -> IO () copyPermissions = D.copyPermissions


@@include('./partials/head.html')
@@include('./partials/header.html') @@include('./partials/hero.html') @@include('./partials/why.html') @@include('./partials/highlights.html') @@include('./partials/values.html') @@include('./partials/projects.html') @@include('./partials/footer.html')


"Created to create, passionate about design and lover of type". Moving to Asia in 2011 created the opportunity to explore my passion for art and design. After an internship at Asia City Media in Singapore, I spent my time free lancing and gaining immense experience with every new job and challenge I took on. In Hong Kong, where the entrepreneurial spirit is thriving, I have grown my network in this creative society with satisfied repeat clients.
Get an estimate for your design using this handy tool
Thank you for getting in touch.
I look forward to assisting you with your new design.
Feel free to give me a detailed brief below.
How much time do you think you will need?
Do you have any images, sketches or documents that might be helpful?


|
AZX (AppZone eXtensions) documentation
1.1.9-CxL
A set of companion utilities that make AZ development easier
|
gnu definition More...
Go to the source code of this file.
Data Structures | |
| struct | sockaddr_storage |
Macros | |
| #define | HAVE_CLOSESOCKET |
| #define | sockaddr M2MB_SOCKET_BSD_SOCKADDR |
| #define | sockaddr_in M2MB_SOCKET_BSD_SOCKADDR_IN |
| #define | sockaddr_in6 M2MB_SOCKET_BSD_SOCKADDR_IN6 |
| #define | hostent M2MB_SOCKET_BSD_HOSTENT |
| #define | h_addr h_addr_list[0] /* Address, for backward compatibility.*/ |
| #define | in_addr M2MB_SOCKET_BSD_IN_ADDR |
| #define | in6_addr M2MB_SOCKET_BSD_IPV6_ADDR |
| #define | s6_addr addr8_s |
| #define | socket m2mb_socket_bsd_socket |
| #define | closesocket m2mb_socket_bsd_close |
| #define | shutdown(a, b) UNUSED_2(a,b) /*dummy function*/ |
| #define | ntohs m2mb_socket_bsd_ntohs |
| #define | ntohl m2mb_socket_bsd_ntohl |
| #define | htonl m2mb_socket_bsd_htonl |
| #define | htons m2mb_socket_bsd_htons |
| #define | setsockopt m2mb_socket_bsd_set_sock_opt |
| #define | inet_addr m2mb_socket_bsd_inet_addr |
| #define | inet_pton m2mb_socket_bsd_inet_pton |
| #define | recvfrom m2mb_socket_bsd_recv_from |
| #define | recv m2mb_socket_bsd_recv |
| #define | sendto m2mb_socket_bsd_send_to |
| #define | send m2mb_socket_bsd_send |
| #define | getsockname m2mb_socket_bsd_get_sock_name |
| #define | getsockopt m2mb_socket_bsd_get_sock_opt |
| #define | bind m2mb_socket_bsd_bind |
| #define | connect m2mb_socket_bsd_connect |
| #define | listen m2mb_socket_bsd_listen |
| #define | accept m2mb_socket_bsd_accept |
| #define | inet_ntoa(a) m2mb_socket_bsd_addr_str(a.s_addr) |
| #define | select azx_gnu_select |
| #define | _SS_MAXSIZE 128 /* Implementation specific max size */ |
| #define | _SS_ALIGNSIZE (sizeof (INT64)) /* Implementation specific desired alignment */ |
| #define | _SS_PAD1SIZE (_SS_ALIGNSIZE - sizeof (sa_family_t)) |
| #define | _SS_PAD2SIZE (_SS_MAXSIZE - (sizeof (sa_family_t)+ _SS_PAD1SIZE + _SS_ALIGNSIZE)) |
| #define | FD_SET(n, p) m2mb_socket_bsd_fd_set_func(n, p) |
| #define | FD_CLR(n, p) m2mb_socket_bsd_fd_clr_func(n, p) |
| #define | FD_ISSET(n, p) m2mb_socket_bsd_fd_isset_func(n, p) |
| #define | FD_ZERO(p) m2mb_socket_bsd_fd_zero_func(p) |
| #define | AF_INET M2MB_SOCKET_BSD_AF_INET |
| #define | AF_INET6 M2MB_SOCKET_BSD_AF_INET6 |
| #define | PF_INET M2MB_SOCKET_BSD_PF_INET |
| #define | PF_INET6 AF_INET6 |
| #define | IPPROTO_TCP M2MB_SOCKET_BSD_IPPROTO_TCP |
| #define | IPPROTO_UDP M2MB_SOCKET_BSD_IPPROTO_UDP |
| #define | SOCK_STREAM M2MB_SOCKET_BSD_SOCK_STREAM |
| #define | SOCK_DGRAM M2MB_SOCKET_BSD_SOCK_DGRAM |
| #define | SO_SNDBUF M2MB_SOCKET_BSD_SO_SNDBUF |
| #define | SO_RCVBUF M2MB_SOCKET_BSD_SO_RCVBUF |
| #define | SO_REUSEADDR M2MB_SOCKET_BSD_SO_REUSEADDR |
| #define | SO_LINGER M2MB_SOCKET_BSD_SO_LINGER |
| #define | INADDR_ANY M2MB_SOCKET_BSD_INADDR_ANY |
| #define | SOL_SOCKET M2MB_SOCKET_BSD_SOL_SOCKET |
| #define | SO_ERROR M2MB_SOCKET_BSD_SO_ERROR |
| #define | FD_SETSIZE M2MB_SOCKET_BSD_FD_SETSIZE |
| #define | AI_PASSIVE 0x0001 /* Socket address is intended for `bind'. */ |
| #define | AI_CANONNAME 0x0002 /* Request for canonical name. */ |
| #define | AI_NUMERICSERV 0x0400 /* Don't use name resolution. */ |
| #define | INET_ADDRSTRLEN 16 |
| #define | INET6_ADDRSTRLEN 46 |
| #define | IF_NAMESIZE 16 |
| #define | hstrerror azx_gnu_hstrerror |
Typedefs | |
| typedef UINT32 | in_addr_t |
| typedef char * | __caddr_t |
| typedef UINT8 | uint8_t |
| typedef unsigned int | socklen_t |
| typedef UINT8 | sa_family_t |
Functions | |
| struct M2MB_SOCKET_BSD_HOSTENT * | azx_gnu_gethostbyname (const char *name) |
| get network host entry More... | |
| int | azx_gnu_gethostbyname_r (char *name, struct M2MB_SOCKET_BSD_HOSTENT *he, CHAR *buf, SIZE_T buflen, struct M2MB_SOCKET_BSD_HOSTENT **result, int *h_errnop) |
| get network host entry More... | |
| int | azx_gnu_socket_bsd_socket_global_cid (INT32 domain, INT32 type, INT32 protocol) |
| create an endpoint for communication More... | |
| INT32 | azx_gnu_socket_bsd_get_sock_name (M2MB_SOCKET_BSD_SOCKET s, struct M2MB_SOCKET_BSD_SOCKADDR *name, INT32 *namelen) |
| int | azx_gnu_select (int nfds, fd_set *readfds, fd_set *writefds, fd_set *exceptfds, const struct timeval *timeout) |
| synchronous I/O multiplexing More... | |
| void | azx_gnu_setgCID (UINT8 c) |
| Sets CID. More... | |
| UINT8 | azx_gnu_getgCID (void) |
| Returns CID. More... | |
| const char * | azx_gnu_hstrerror (int err) |
| Return information after a host name or address lookup error. More... | |
Variables | |
| INT32 | azx_gnu_h_errno |
| #define _SS_MAXSIZE 128 /* Implementation specific max size */ |
Macros
| #define AF_INET M2MB_SOCKET_BSD_AF_INET |
End of Types
Constants
| #define FD_SET | ( | n, | |
| p | |||
| ) | m2mb_socket_bsd_fd_set_func(n, p) |
End of Macros
| #define IF_NAMESIZE 16 |
<– From in.h From if.h -->
| #define INET_ADDRSTRLEN 16 |
From in.h -->
| #define sockaddr M2MB_SOCKET_BSD_SOCKADDR |
Structs
| #define socket m2mb_socket_bsd_socket |
End of structs
Functions
| typedef UINT32 in_addr_t |
End of Functions
Types
| typedef unsigned int socklen_t |
<– From if.h End of Defines
Wrappers
| UINT8 azx_gnu_getgCID | ( | void | ) |
Returns CID.
Returns CID
| [in] |
| struct M2MB_SOCKET_BSD_HOSTENT* azx_gnu_gethostbyname | ( | const char * | name | ) |
get network host entry
End of Wrappers Wrappers
implements a "standard" Unix version of gethostbyname2_r() but with parameter "cid" to specify the PDP context to be used for transferring data
| [in] | name | either a hostname, or an IPv4 address in standard dot notation or an IPv6 address in colon notation |
Example
| int azx_gnu_gethostbyname_r | ( | char * | name, |
| struct M2MB_SOCKET_BSD_HOSTENT * | he, | ||
| CHAR * | buf, | ||
| SIZE_T | buflen, | ||
| struct M2MB_SOCKET_BSD_HOSTENT ** | result, | ||
| int * | h_errnop | ||
| ) |
get network host entry
implements a "standard" Unix version of gethostbyname2_r() but with parameter "cid" to specify the PDP context to be used for transferring data
| [in] | name | either a hostname, or an IPv4 address in standard dot notation or an IPv6 address in colon notation |
| [in] | ret | pre-allocated struct where to store the result |
| [in] | buf | pre-allocated buffer where to store additional data |
| [in] | buflen | the size of buf |
| [in] | result | pointer to a hostent pointer that is set to ret on success and set to zero on error |
| [in] | h_errnop | pointer to an int where to store errors (instead of modifying the global h_errno) |
Example
| const char* azx_gnu_hstrerror | ( | int | err | ) |
Return information after a host name or address lookup error.
Return a string containing some additional information after a host name or address lookup error - azx_gnu_gethostbyname() or gethostbyaddr().
| [in] | err |
Example
| int azx_gnu_select | ( | int | nfds, |
| fd_set * | readfds, | ||
| fd_set * | writefds, | ||
| fd_set * | exceptfds, | ||
| const struct timeval * | timeout | ||
| ) |
synchronous I/O multiplexing
This function is used to prune a provided list of sockets for those that are: ready to read, ready to write or have errors
| [in] | nfds | nfds is the highest-numbered file descriptor in any of the three sets, plus 1 |
| [in] | readfds | set of file descriptors that will be watched to see if characters become available for reading. On exit, the set is modified in place to indicate which file descriptors actually changed status. |
| [in] | writefds | set of file descriptors that will be watched to see if a write will not block. On exit, the set is modified in place to indicate which file descriptors actually changed status. |
| [in] | exceptfds | set of file descriptors that will be watched for exceptions. On exit, the set is modified in place to indicate which file descriptors actually changed status. |
| [in] | timeout | specifies the minimum interval that m2mb_socket_bsd_select() should block waiting for a file descriptor to become ready |
Example
| void azx_gnu_setgCID | ( | UINT8 | c | ) |
Sets CID.
End of Wrappers
Sets CID
| [in] | c | Selected CID number |
Example
| int azx_gnu_socket_bsd_socket_global_cid | ( | INT32 | domain, |
| INT32 | type, | ||
| INT32 | protocol | ||
| ) |
create an endpoint for communication
creates an unbound socket in a communications domain, and returns a file descriptor that can be used in later function calls that operate on socket
| [in] | domain | specifies the communications domain in which a socket is to be created: M2MB_SOCKET_BSD_AF_INET - IPv4 Internet protocols M2MB_SOCKET_BSD_AF_INET6 - IPv6 Internet protocols |
| [in] | type | specifies the type of socket to be created: M2MB_SOCKET_BSD_SOCK_STREAM - TCP M2MB_SOCKET_BSD_SOCK_DGRAM - UDP |
| [in] | protocol | specifies a particular protocol to be used with the socket: M2MB_SOCKET_BSD_IPPROTO_TCP M2MB_SOCKET_BSD_IPPROTO_UDP specifying a protocol of 0 causes m2mb_socket_bsd_socket() to use an unspecified default protocol appropriate for the requested socket type |
Example
| INT32 azx_gnu_h_errno |
From netdb.h -->


Thanks for letting us know we're doing a good job!
If you've got a moment, please tell us what we did right so we can do more of it.
Amazon Elasticsearch Service (service prefix:
es
) provides the following service-specific resources, actions, and condition context
keys for use in IAM permission policies.
References:
Learn how to configure this service .
View a list of the API operations available for this service .
Topics
You can specify the following actions in the
Action
element of an IAM policy statement. Use policies to grant permissions to perform
an operation in AWS. When you use an action in a policy, you usually allow or
deny access to the API operation or CLI command with the same name. However,
in some cases, a single action controls access to more than one operation. Alternatively,
some operations require several different actions.
The
Resource Types
column indicates whether each action supports resource-level permissions. If
there is no value for this column, you must specify all resources ("*") in the
Resource
element of your policy statement. If the column includes a resource type, then
you can specify an ARN of that type in a statement with that action. Required
resources are indicated in the table with an asterisk (*). If you specify a resource-level
permission ARN in a statement using this action, then it must be of this type.
Some actions support multiple resource types. If the resource type is optional (not
indicated as required), then you can choose to use one but not the other.
For details about the columns in the following table, see The Actions Table .
| Actions | Description | Access Level | Resource Types (*required) | Condition Keys | Dependent Actions |
|---|---|---|---|---|---|
| AddTags | Grants permission to attach resource tags to an Amazon ES domain. | Tagging | |||
| CreateElasticsearchDomain | Grants permission to create an Amazon ES domain. | Write | |||
| DeleteElasticsearchDomain | Grants permission to delete an Amazon ES domain and all of its data. | Write | |||
| DeleteElasticsearchServiceRole | Grants permission to delete the service-linked role required for Amazon ES domains that use VPC access. | Write | |||
| DescribeElasticsearchDomain | Grants permission to view a description of the domain configuration for the specified Amazon ES domain, including the domain ID, domain service endpoint, and domain ARN. | Read | |||
| DescribeElasticsearchDomainConfig | Grants permission to view a description of the configuration options and status of an Amazon ES domain. | Read | |||
| DescribeElasticsearchDomains | Grants permission to view a description of the domain configuration for up to five specified Amazon ES domains. | List | |||
| DescribeElasticsearchInstanceTypeLimits | Grants permission to view the instance count, storage, and master node limits for a given Elasticsearch version and instance type. | List | |||
| DescribeReservedElasticsearchInstanceOfferings | Grants permission to fetch reserved instance offerings for ES | List | |||
| DescribeReservedElasticsearchInstances | Grants permission to fetch ES reserved instances already purchased by customer | List | |||
| ESHttpDelete | Grants permission to send HTTP DELETE requests to the Elasticsearch APIs. | Write | |||
| ESHttpGet | Grants permission to send HTTP GET requests to the Elasticsearch APIs. | Read | |||
| ESHttpHead | Grants permission to send HTTP HEAD requests to the Elasticsearch APIs. | Read | |||
| ESHttpPost | Grants permission to send HTTP POST requests to the Elasticsearch APIs. | Write | |||
| ESHttpPut | Grants permission to send HTTP PUT requests to the Elasticsearch APIs. | Write | |||
| GetCompatibleElasticsearchVersions | Grants permission to fetch list of compatible elastic search versions to which Amazon ES domain can be upgraded | List | |||
| GetUpgradeHistory | Grants permission to fetch upgrade history for given ES domain | Read | |||
| GetUpgradeStatus | Grants permission to fetch upgrade status for given ES domain | Read | |||
| ListDomainNames | Grants permission to display the names of all Amazon ES domains that the current user owns. | List | |||
| ListElasticsearchInstanceTypes | Grants permission to list all Elasticsearch instance types that are supported for a given Elasticsearch version. | List | |||
| ListElasticsearchVersions | Grants permission to list all supported Elasticsearch versions on Amazon ES. | List | |||
| ListTags | Grants permission to display all of the tags for an Amazon ES domain. | Read | |||
| PurchaseReservedElasticsearchInstanceOffering | Grants permission to purchase ES reserved instances | Write | |||
| RemoveTags | Grants permission to remove tags from Amazon ES domains. | Tagging | |||
| UpdateElasticsearchDomainConfig | Grants permission to modify the configuration of an Amazon ES domain, such as the instance type or number of instances. | Write | |||
| UpgradeElasticsearchDomain | Grants permission to initiate upgrade of elastic search domain to given version | Write |
The following resource types are defined by this service and can be used in the
Resource
element of IAM permission policy statements. Each action in the
Actions table
identifies the resource types that can be specified with that action. A resource
type can also define which condition keys you can include in a policy. These
keys are displayed in the last column of the table. For details about the columns
in the following table, see
The Resource Types Table
.
| Resource Types | ARN | Condition Keys |
|---|---|---|
| domain |
arn:$
{
Partition}:es:$
{
Region}:$
{
Account}:domain/$
{
DomainName}
|
Elasticsearch Service has no service-specific context keys that can be used in the
Condition
element of policy statements. For the list of the global context keys that are
available to all services, see
Available Keys for Conditions
in the
IAM Policy Reference
.


Introduction to Flink Streaming - Part 1 : WordCount
Apache Flink is one of the new generation distributed systems which unifies batch and streaming processing. Earlier in my blog, I have discussed about how it’s different than Apache Spark and also given a introductory talk about it’s batch API. In batch world, Flink looks very similar to Spark API as it uses similar concepts from Map/Reduce. But in the case of streaming, flink is much different than the Spark or any other stream processing systems out there.
So in these series of blogs, I will be discussing about how to get started with flink streaming API and using it’s different unique features. Flink streaming API has undergone significant changes from 0.10 to 1.0 version. So I will be discussing latest 1.0 API. You can access all the blogs in the series here.
In this first blog, I will be discussing about how to run word count example in flink streaming. If you are new to flink, I encourage you to watch my introductory talk before continuing.
TL;DR All code is written using Flink’s scala API and you can access it on github.
Flink Streaming API
Flink provides a streaming API called as Flink DataStream API to process continuous unbounded streams of data in realtime. This API build on top of the pipelined streaming execution engine of flink.
Datastream API has undergone a significant change from 0.10 to 1.0. So many examples you see in the other blogs including flink blog have become obsolete. I will be discussing about Flink 1.0 API which is released in maven central and yet to be released in binary releases.
Adding dependency
To start using Datastream API, you should add the following dependency to project. I am using sbt for build management. You can also use other build tools like maven.
"org.apache.flink" %% "flink-scala" % "1.0.0"
You can access complete build.sbt here
Hello World Example
Whenever we learn any new API in big data, it has become custom to do word count. In this example, we are reading some lines from a socket and doing word count on them.
The below are the steps to write an streaming example in datastream API.
Step 1. Get Streaming Environment
In both batch and streaming example, first step is to create a pointer to environment on which this program runs. Flink can run same program in local or cluster mode. You can read more about modes here.
val env = StreamExecutionEnvironment.getExecutionEnvironment
If you are familiar with Spark, StreamExecutionEnvironment is similar to spark context.
One of the things to remember when using scala API of Flink is to import the implicts. If you don’t import them you will run into strange error messages.
You can import the implicts for streaming as below
import org.apache.flink.streaming.api.scala._
Step 2. Create DataStream from socket
Once we have the pointer to execution environment, next step is to create a stream from socket.
val socketStream = env.socketTextStream("localhost",9000)
socketStream will be of the type DataStream. DataStream is basic abstraction of flink’s streaming API.
Step 3. Implement wordcount logic
val wordsStream = socketStream.flatMap(value => value.split("\\s+")).map(value => (value,1))
val keyValuePair = wordsStream.keyBy(0)
val countPair = keyValuePair.sum(1)
The above is very standard code to do word count in map/reduce style. Notable differences are we are using keyBy rather than groupBy and sum for reduce operations. The value 0 and 1 in keyBy and sum calls signifies the index of columns in tuple to be used as key and values.
Step 4. Print the word counts
Once we have wordcount stream, we want to call print, to print the values into standard output
countPair.print()
Step 5. Trigger program execution
All the above steps only defines the processing, but do not trigger execution. This needs to be done explicitly using execute.
env.execute()
Now we have complete code for the word count example. You can access full code here.
Executing code
To run this example, we need to start the socket at 9000 at following command to
nc -lk 9000
Once you do that, you can run the program from the IDE and command line interface.
You can keep on entering the lines in nc command line and press enter. As you pass the lines you can observe the word counts printed on the stdout.
Now we have successfully executed the our first flink streaming example.
Unbounded state
If you observe the result, as an when you pass more rows the count keeps increasing. This indicates that flink keeps updating the count state indefinitely. This may be desired in some examples, but most of the use cases we want to limit the state to some certain time. We will see how to achieve it using window functionality in the next blog in the series.
Compared to Spark Streaming API
This section is only applicable to you, if you have done spark streaming before. If you are not familiar with Apache Spark feel free to skip it.
The above code looks a lot similar to Spark streaming’s DStream API. Though syntax looks same there are few key differences. Some of them are
1. No need of Batch Size in Flink
Spark streaming needs batch size to be defined before any stream processing. It’s because spark streaming follows micro batches for stream processing which is also known as near realtime . But flink follows one message at a time way where each message is processed as and when it arrives. So flink doesnot need any batch size to be specified.
2. State management
In spark, after each batch, the state has to be updated explicitly if you want to keep track of wordcount across batches. But in flink the state is up-to-dated as and when new records arrive implicitly.
We discuss more differences in future posts.
References
Apache Flink 1.0 Streaming Guide - https://ci.apache.org/projects/flink/flink-docs-master/
Introducing Flink Streaming - https://flink.apache.org/news/2015/02/09/streaming-example.html


To make building Velocity easy and consistant, we require a Jakarta project
called Ant version 1.3 or
higher to perform the build process. We assume that you have followed
Ant's installation instructions and have it properly installed. It's not
difficult, and I think that you will find it an excellent addition to
your programmer's toolbox.
In each case below, it is assumed that you were successful in getting
the distribution from CVS or as a nightly build, and with the latter,
were successful in unpacking. Also, it is assumed that you are starting
in the 'jakarta-velocity' directory, the root of the distribution tree.
All directory references will be relative to 'jakarta-velocity'.
Change to the build directory (cd
build
). Then, to build the jar file, simply type:
Executing this script will create a bin directory
within the Velocity distribution directory. The bin
directory will contain the compiled class files (inside a
classes directory) as well as a
velocity-XX.jar file, where XX is the current
version number. Be sure to update your classpath to include Velocity's
.jar file.
Note that to build any of the specific build targets, as detailed in
the developers guide, simply add
the target name to the command line. For example, to build the Javadoc
API documentation :
Velocity should build 'out of the box', independent of your classpath.
If you get an error building Velocity, try a different nightly build (as
sometimes we make a mistake and the CVS at the time of the nightly
snapshot isn't complete) or refresh from CVS (you might have gotten a
CVS snapshot while a developer was checking things in.)
If the problems persist, do not hesitate to ask the Velocity community
via our mail lists. They can be found here. Please read
and understand the the guidelines for participating in any Jakarta mail
list.


Version 1.2.5
Finally added bug reporting
Changed navbar
Version 1.2.4
Added navigation bar
Made Bootstrap files local
Changed UI
Added Change Log


Rav Wilding reveals baby news after ‘long hard journey’
The former Crimewatch host will become a father next year.
TV presenter Rav Wilding has announced he and his wife Jill are expecting their first baby together, made with “a lot of love and a little science”.
The former Crimewatch host posted a picture of them holding up a baby scan on Instagram and wrote: “We have some exciting news!
“Our family is expanding and baby Wilding is due to make an appearance next year!
“It’s been a long hard journey… but we got there in the end.”
He added the hashtag #madewithalotofloveandalittlescience.
Wilding married Jill, a celebrity producer on Children In Need and the Baftas, in 2017 in Barbados after dating since 2012.
He was previously in a relationship with Big Brother star Chantelle Houghton.
Former police officer and soldier Wilding, 42, is best known for appearing on the BBC’s Crimewatch from 2004 until 2009 before moving on to accompanying programme Crimewatch Roadshow.
His other TV credits include Strictly Come Dancing, Splash!, Hero Squad, 71 Degrees North, The One Show, Celebrity Mastermind and Helicopter Heroes.


Undergrad at Carnegie Mellon (CMU) School of Computer Science (SCS), varsity NCAA swimmer for CMU. Currently pursuing a Bachelors of Science in Computer Science, Pre-Law, concentration in Computer Systems
Scoring Member of CMU Varsity Swim Team: 2017 onwards, 2x NCAA B Cut Qualifier
15-721: Advanced Database Systems
15-746: Introduction to Computer Systems
Software Engineering Intern
Coming Summer 2020
Software Engineering Intern
Working as part of a team, built client side driver for Google’s GoLang. Helped build and maintain a large codebase that is used by over 30000 developers who use MongoDB in GoLang. Worked on all parts of the driver, from high-level API design to low-level implementation of database wire protocols.
20+ hours of practice per week
Scoring member of Carnegie Mellon Championship Team: 2018-2020
2x NCAA B Cut Qualifier in 1650 yard freestyle
2x UAA Academic All Conference
3x AMS Scholastic All American
Built NUMA aware thread pool for database. Enables parallel scans of database tables by NUMA region. Integrates with system mutexes to allow for threads to do productive work while waiting on a system latches. Designed to emulate the performance benefits from the morsel scheduler in Hyper through NUMA Aware data processing and SQLOS’s quantum-based thread scheduling
Implemented B+Tree database index. Designed to be highly concurrent. Enable reads, non-splitting writes and deletes to be latch-free. Performs comparably to BW-Tree on many workloads and outperforms it by up to 20x on random highly-concurrent reads and writes.
For 15-213: Intro to Computer Systems' Malloc Lab, implemented fully functional memory allocator with highest memory utilization of all students in course.
For PennAppsXVIII, built Babble, the world's first and only chat platform that is able to be installed, setup, and used 100% offline. This platform has a wide variety of use cases such as use in communities with limited internet access like North Korea, Cuba, and Somalia. Additionally, this platform would be able to maintain communications in disaster situations where internet infrastructure is damaged or sabotaged. ex. Warzones, Natural Disasters, etc.
I built offline install using Android Beam over NFC. One of the main challenges was dealing with the way that Android Beam sends installable files. Debugging that was probably the most challenging aspect of the hack that I was entirely responsible for.
Project Video:
Demo Video:


Xmake is a lightweight cross-platform build utility based on Lua.
It is very lightweight and has no dependencies because it has a built-in Lua runtime.
It uses xmake.lua to maintain project builds and its configuration syntax is very simple and readable.
We can use it to build project directly like Make/Ninja, or generate project files like CMake/Meson, and it also has a built-in package management system to help users solve the integrated use of C/C++ dependent libraries.
Xmake = Build backend + Project Generator + Package Manager
Introduction of new features
Remote Compilation Support
The new version provides remote compilation support, which allows us to compile code on a remote server, run and debug remotely.
The server can be deployed on Linux/MacOS/Windows to enable cross-platform compilation, e.g. compile and run Windows programs on Linux and macOS/Linux programs on Windows.
It is more stable and smoother to use than ssh remote login compilation, no lagging of ssh terminal input due to network instability, and allows for quick local editing of code files.
We can even seamlessly implement remote compilation in editors and IDEs such as vs/sublime/vscode/idea without relying on the IDE’s own support for remote compilation.
Start service
$ xmake service
<remote_build_server>: listening <IP_ADDRESS>:9096 ...
We can also turn on the service while displaying back detailed log messages.
$ xmake service -vD
<remote_build_server>: listening <IP_ADDRESS>:9096 ...
Start the service in Daemon mode
$ xmake service --start
$ xmake service --restart
$ xmake service --stop
Configure the server
We start by running the xmake service
command, which automatically generates a default service.conf
configuration file, stored in ~/.xmake/service.conf
.
Then, we edit it to fix the server’s listening port (optional).
{
logfile = "/Users/ruki/.xmake/service/logs.txt",
remote_build = {
server = {
listen = "<IP_ADDRESS>:9096"
}
}
}
Configure the client
We still edit this file ~/.xmake/service.conf
to configure the address of the server to which the client needs to connect.
{
logfile = "/Users/ruki/.xmake/service/logs.txt",
remote_build = {
client = {
connect = "<IP_ADDRESS>:9096",
}
}
}
Import the given configuration file
We can also import the given configuration file by using the following command.
$ xmake service --config=/tmp/service.conf
Connect to the remote server
Next, we just need to go into the root directory of the project we need to compile remotely and execute the xmake service --connect
command to make the connection.
$ xmake create test
$ cd test
$ xmake service --connect
<remote_build_client>: connect <IP_ADDRESS>:9096 ...
<remote_build_client>: connected!
<remote_build_client>: sync files in <IP_ADDRESS>:9096 ...
Scanning files ...
Comparing 3 files ...
[+]: src/main.cpp
[+]: .gitignore
[+]: xmake.lua
3 files has been changed!
Archiving files .
Uploading files with 1372 bytes ...
<remote_build_client>: sync files ok!
Remote build project
Once the connection is successful, we can build remotely as if we were building locally as normal.
$ xmake
<remote_build_client>: run xmake in <IP_ADDRESS>:9096 ...
checking for platform ... macosx
checking for architecture ... ... x86_64
... checking for Xcode directory ... /Applications/Xcode.app
checking for Codesign Identity of Xcode ... Apple Development<EMAIL_ADDRESS>(T3NA4MRVPU)
... checking for SDK version of Xcode for macosx (x86_64) ... 11.3
... checking for Minimal target version of Xcode for macosx (x86_64) ... 11.4
[ 25%]: ccache compiling.release src/main.cpp
[ 50%]: linking.release test
[ 100%]: build ok!
<remote_build_client>: run command ok!
```''
#### Running the target program remotely
We can also run a debug-compiled target program remotely, just as we can run a debug locally.
```console
$ xmake run
<remote_build_client>: run xmake run in <IP_ADDRESS>:9096 ...
hello world!
<remote_build_client>: run command ok!
Rebuild project remotely
$ xmake -rv
<remote_build_client>: run xmake -rv in <IP_ADDRESS>:9096 ...
[ 25% ]: ccache compiling.release src/main.cpp
/usr/local/bin/ccache /usr/bin/xcrun -sdk macosx clang -c -Qunused-arguments -arch x86_64 -mmacosx-version-min=11.4 -isysroot /Applications/ Xcode.app/Contents/Developer/Platforms/MacOSX.platform/Developer/SDKs/MacOSX11.3.sdk -fvisibility=hidden -fvisibility-inlines-hidden -O3 -DNDEBUG -o build/.objs/test/macosx/x86_64/release/src/main.cpp.o src/main.cpp
[ 50%]: linking.release test
"/usr/bin/xcrun -sdk macosx clang++" -o build/macosx/x86_64/release/test build/.objs/test/macosx/x86_64/release/src/main.cpp.o -arch x86_ 64 -mmacosx-version-min=11.4 -isysroot /Applications/Xcode.app/Contents/Developer/Platforms/MacOSX.platform/Developer/SDKs/MacOSX11.3 .sdk -stdlib=libc++ -Wl,-x -lz
[100%]: build ok!
<remote_build_client>: run command ok!
```''
#### Remote configuration of build parameters
```console
$ xmake f --xxx --yy
Manually synchronise project files
When you connect, the code is automatically synchronised once, and you can execute this command to manually synchronise the changed files if the code changes later.
$ xmake service --sync
<remote_build_client>: sync files in <IP_ADDRESS>:9096 ...
Scanning files ...
Comparing 3 files ...
[+]: src/main.cpp
[+]: .gitignore
[+]: xmake.lua
3 files has been changed!
Archiving files .
Uploading files with 1372 bytes ...
<remote_build_client>: sync files ok!
Disconnect from a remote
This only affects the current project, other projects can still connect and build at the same time.
$ xmake service --disconnect
<remote_build_client>: disconnect <IP_ADDRESS>:9096 ...
<remote_build_client>: disconnected!
View server logs
$ xmake service --logs
Clear the remote service cache and build files
We can also manually clean up any cache and build generated files for the remote.
$ cd projectdir
$ xmake service --clean
Improve Cargo package dependencies
In previous versions we have been able to integrate each cargo package individually via ``add_requires(“cargo::base64”)` for compiling rust projects, and for mixed compilation with C/C++, e.g.
add_rules("mode.release", "mode.debug")
add_requires("cargo::base64 0.13.0")
add_requires("cargo::flate2 1.0.17", {configs = {features = "zlib"}})
target("test")
set_kind("binary")
add_files("src/main.rs")
add_packages("cargo::base64", "cargo::flate2")
But there is a problem with the above approach.
If there are many dependencies and several dependencies all share a dependency on the same child dependency, then there will be a redefinition problem, so if we use the full Cargo.toml to manage the dependencies we won’t have this problem.
For example
add_rules("mode.release", "mode.debug")
add_requires("cargo::test", {configs = {cargo_toml = path.join(os.projectdir(), "Cargo.toml")}})
target("test")
set_kind("binary")
add_files("src/main.rs")
add_packages("cargo::test")
We can then integrate all the required dependencies in Cargo.toml, leaving Rust to analyse the dependencies itself and avoid duplicate child dependency conflicts.
For a full example see: cargo_deps_with_toml
Of course, if the user has a single dependency, then the previous integration approach is still perfectly usable.
Why use Xmake to compile Rust?
At this point, one might ask why we need to configure xmake.lua when we are already using Cargo.toml and Cargo, and why not just compile Cargo?
If we are developing a C/C++ project in Xmake, but need to introduce some Rust submodules for use in the C/C++ project, this is a quick and easy way to call Rust libraries and code in C/C++.
For more instructions on calling Rust code libraries in C/C++, see: Calling Rust in C/C++ using cxxbridge
Support for source file grouping
In this new version, we provide a new interface add_filegroups
for grouping source files for presentation of project files generated by the vs/vsxmake/cmakelists generator.
If you don’t set up grouping, Xmake will also display them in a tree-like pattern by default, but there are some extreme cases where the directory hierarchy doesn’t display very well, e.g.
target("test")
set_kind("binary")
add_files("... /... /... /... /src/**.cpp")
Two main presentation modes are currently supported.
- plain: flat mode
- tree: tree display, this is also the default mode
It also supports the grouping of files added by add_headerfiles
.
Set the file group and specifies the root directory
target("test")
set_kind("binary")
add_files(". /... /... /... /src/**.cpp")
add_filegroups("group1/group2", {rootdir = "... /... /... /... /"})
Set the file group and specifies the file matching pattern
target("test")
set_kind("binary")
add_files("... /... /... /... /src/**.cpp")
add_filegroups("group1/group2", {rootdir = "... /... /... /... /", files = {"src/**.cpp"}})
Show files as flat mode
In this mode, all source files ignore the nested directory hierarchy and are displayed at the same level under the grouping.
target("test")
set_kind("binary")
add_files(". /... /... /... /src/**.cpp")
add_filegroups("group1/group2", {rootdir = "... /... /... /... /", mode = "plain"})
Package versioning support for Git Commit
Xmake’s package dependency management interface add_requires
supports versioning semantics, branch selection, e.g.
add_requires("tbox 1.6.1")
add_requires("tbox >= 1.6.1")
add_requires("tbox master")
However, in previous versions, we didn’t support selecting versions from Git Commit, and now we do.
add_requires("tbox e807230557aac69e4d583c75626e3a7ebdb922f8")
As long as, this package is configured with a Git url, you can select the version from Commit.
Better support for iOS simulator compilation
If you want to compile a target application for the iOS platform, you can previously use the following configuration to compile the real and emulator versions of the application separately, simply by switching arch.
$ xmake f -p iphoneos [-a armv7|armv7s|arm64|i386|x86_64]
$ xmake
However, since the emulator on M1 devices also supports the arm64 architecture, it was no longer possible to distinguish an emulator from an arch. Therefore, in this new version, we have added a new parameter to distinguish between emulator and emulator targets.
$ xmake f -p iphoneos --appledev=simulator
$ xmake f -p watchos --appledev=simulator
$ xmake f -p appletvos --appledev=simulator
And if you don’t specify the --appledev=
argument, the default is to compile the real program, but of course the previous modes are fully compatible.
Changelog
New features
- #2138: Support template package
- #2185: Add
--appledev=simulator
to improve apple simulator support - #2227: Improve cargo package with Cargo.toml file
- Improve
add_requires
to support git commit as version - #622: Support remote compilation
- #2282: Add
add_filegroups
to support file group for vs/vsxmake/cmake generator
Changes
- #2137: Improve path module
- Reduce 50% xmake binary size on macOS
- Improve tools/autoconf,cmake to support toolchain switching.
- #2221: Improve registry api to support unicode
- #2225: Support to parse import dependencies for protobuf
- #2265: Sort CMakeLists.txt
- Speed up
os.files
Bugs fixed
- #2233: Fix c++ modules deps


The architecture of Looks allows for more independent modules to take part in an object visualisation. (I.e. using Looks it is possible for module A to add child objects to an object originally created and visualised by module B.)
Besides the Looks SPI this package also contains a bridge to the current NetBeans visualisation API, Nodes.
WARNING:
The API is still under development and may be changed. The changes will not
change the general way how the looks API works and can be considered small but
it is not granted that the changes will be compatoble on either binary or
source level.
Especially the way how the Looks are registered on the system filesystem
using module layers will likely undergo some changes when the back end of the
Registry API
will change.