2018年9月3日Qubic开发状态更新

IOTA区块大康2018-09-06 22:46:41  阅读 -评论 0  阅读原文

八月份的任务是整理Qubic编程语言Abra的细节。我们最终敲定了许多与语言语法相关的细节,并开始研究项目用户体验的设计。研究结果很有希望并巩固了我们的信念,即我们应该可以在2018年年底前后展示Qubic实现的概念验证。

我们还开始编写Qubic计算模型的文档。文档深入介绍了如何将Abra程序转换为我们称之为Handy的中间三进制数位代码(trit-code)表示。文档还将详细的说明代码如何与Qubic Dispatcher交互,Qubic Dispatcher是支持Qubic的节点上的Qubic任务和事件的调度程序。

Handy将Abra程序编码为一种紧凑的三进制表示,这样就可以轻松地将其打包到Qubic交易中并发布到Tangle上。Handy会在打包之前对Abra程序中的所有错误进行语法检查和标记,这意味着任何后期处理工具(比如Qubic Dispatcher)都不再需要重复这个操作。

Qubic Dispatcher在支持qubic的节点上运行,并将Qubic trit-code转换为它的目标架构。Dispatcher还将侦听触发qubics的事件,并将其传递给这些qubics以进行进一步处理。Qubic代码的处理与dispatcher紧密的交织在一起,文档会对此进行详细说明。

完成Qubic计算模型文档的编写是规划中的下一个目标。Abra语法以及与dispatcher的交互是它的两个主要部分。

另一个应该同时准备好的文档是与Qubic背后的数学有关的论文。初始布局已经完成,我们现在正在填充各部分的内容。

与此同时,Abra编译器的工作进展顺利。我们目前正在将最新修订纳入到语言中,并将在下一个版本中完成LLVM代码生成。完成后,我们就可以运行和测试简单、直接的Abra代码。之后将创建dispatcher,代码和dispatcher之间的整体交互应该可以支持创建和测试更复杂的程序。

同时还在对FPGA实现展开研究,以便我们的设计过程始终牢记这一点:我们的关注重点是物联网的节能分布式计算。

出于这个关注重点,我们决定在可以完整的运行qubics之前,推迟对gateway概念(用于使用Qubic转移资金)的进一步研究。这样的gateway首先需要一个可完整运行的系统,然后才能实现和测试它们。

我们还开始为Qubic开发团队寻找新的成员,因为我们认为团队的总体规划已经足够稳定了。我们认识到:人们可以同时致力于项目的不同部分,且不会相互妨碍。

总之,这是一个激动人心的月份,充满了各种见解,我们对Qubic项目的热情与日俱增。

一些Abra示例:

// sample Abra type definitions
// define some standard trit lengths we will use in our examples
// note that you can define the optimal size for any type's range
// to reduce energy requirements accordingly
Trit [1]; // -1 to +1
Tryte [3]; // -13 to +13
Short [9]; // -9,841 to +9,841
Int [27]; // -3,812,798,742,493 to +3,812,798,742,493
Long [81]; // -2.217...e+38 to +2.217...e+38
Hash [243];
State [729];
// convenience type to make code more clear
// supposed to always contain a binary boolean value 0 (false) or 1 (true)
// should never be null or have the value - (convention not enforced by Abra)
Bool [Trit];
// here's how to define a named structured trit vector
// it consists of the concatenation of all sub-vectors
// its size is the sum of all sub-vector sizes
// IOTA transaction layout
Transaction {
signature [27 * Hash]
, extradatadigest [Hash]
, address [Hash]
, value [Long]
, issuancetimestamp [Int]
, timelocklowerbound [Int]
, timelockupperbound [Int]
, bundle [Long]
, trunk [Hash]
, branch [Hash]
, tag [Long]
, attachmenttimestamp [Int]
, attachmenttimestamplowerbound [Int]
, attachmenttimestampupperbound [Int]
, nonce [Long]
};
// sample Abra look-up tables
// these are a look-up tables, or LUTs
// a LUT describes for each combination of input trits what the resulting output trits will be
// any missing explicitly defined combinations will cause the resulting output to be null
// if any input to a LUT is null, the result will be null as well,
// so we only need to specify combinations of non-null input values
// ************* BINARY OPERATORS *************
// LUT logic: binary NOT
// return !trit1;
not [
0 = 1;
1 = 0;
];
// LUT logic: binary AND
// return (trit1 & trit2);
and [
0,0 = 0;
0,1 = 0;
1,0 = 0;
1,1 = 1;
];
// LUT logic: binary OR
// return (trit1 | trit2);
or [
0,0 = 0;
0,1 = 1;
1,0 = 1;
1,1 = 1;
];
// LUT logic: binary XOR
// return (trit1 ^ trit2);
xor [
0,0 = 0;
0,1 = 1;
1,0 = 1;
1,1 = 0;
];
// LUT logic: binary NAND
// return !(trit1 & trit2);
nand [
0,0 = 1;
0,1 = 1;
1,0 = 1;
1,1 = 0;
];
// LUT logic: binary NOR
// return !(trit1 | trit2);
nor [
0,0 = 1;
0,1 = 0;
1,0 = 0;
1,1 = 0;
];
// LUT logic: binary XNOR
// return !(trit1 ^ trit2);
xnor [
0,0 = 1;
0,1 = 0;
1,0 = 0;
1,1 = 1;
];
// ************* TERNARY OPERATORS *************
// LUT logic: return the negative value of the input trit
// return -trit1;
/ note that making an entire trit-vector value negative
// can be done by simply negating every trit in the vector
neg [
- = 1;
0 = 0;
1 = -;
];
// LUT logic: return a boolean indicating whether the two input trits are equal
// return (trit1 == trit2);
equal [
-,- = 1;
-,0 = 0;
-,1 = 0;
0,- = 0;
0,0 = 1;
0,1 = 0;
1,- = 0;
1,0 = 0;
1,1 = 1;
];
// LUT logic: return a boolean indicating whether the two input trits are unequal
// return (trit1 != trit2);
unequal [
-,- = 0;
-,0 = 1;
-,1 = 1;
0,- = 1;
0,0 = 0;
0,1 = 1;
1,- = 1;
1,0 = 1;
1,1 = 0;
];
// LUT logic: when (boolean) trit1 equals 1 return trit2 else return trit3
// return trit1 ? trit2 : trit3;
unequal [
0,-,- = -;
0,-,0 = 0;
0,-,1 = 1;
0,0,- = -;
0,0,0 = 0;
0,0,1 = 1;
0,1,- = -;
0,1,0 = 0;
0,1,1 = 1;
1,-,- = -;
1,-,0 = -;
1,-,1 = -;
1,0,- = 0;
1,0,0 = 0;
1,0,1 = 0;
1,1,- = 1;
1,1,0 = 1;
1,1,1 = 1;
];
// LUT logic: return the 2rd input trit only when 1st input trit equals 1 (true)
// return (trit1 == 1) ? trit1 : null;
nullOrTrit [
1,0 = 0;
1,1 = 1;
1,- = -;
];
// sample Abra functions
// this is a function that takes a trit vector of State [729],
// but we don't need to constantly repeat that size since we
// already established the size at the top of the file
digest(state [State]) =
// a function returns the value of its last statement,
// which in this case is a concatenation (comma operator)
// of the input state and the result of the transform() function
state, transform(state, 81);
// note that this function does not need curly braces around its single statement
// curly braces are only necessary when grouping multiple statements
// construct functions for all predefined types that perform
// a similar task to the nullOrTrit LUT for those larger types
// note that we have defined each successive type a factor 3 times bigger
// which means we can easily define each successive type in terms of the previous one
// every nullOrXxx function returns <val> when <t> equals 1 (true), and null otherwise
// note that it may seem wasteful to define it this way, but when mapped to FPGA
// these can be translated into parallel circuitry that executes them simultaneously.
// for other architectures, Abra will allow the Abra functions to be replaced with
// a dll function that uses optimal architecture-specific instructions.
// we expect a library of common functions to be developed over time
nullOrTryte(t [Bool], val [Tryte]) = {
// concatenate the 3 separate trits via the LUT
nullOrTrit[t, val[0]],
nullOrTrit[t, val[1]],
nullOrTrit[t, val[2]];
};
nullOrShort(t [Bool], val [Short]) = {
// concatenate the 3 separate trytes via the previous function
// note the notation to easily specify a subrange of a trit vector
// we will start at N times the size of Tryte and have an open ended range
// which specifies to take whatever amount necessary to pass to the underlying parameter
nullOrTryte(t, val[0 * Tryte..]),
nullOrTryte(t, val[1 * Tryte..]),
nullOrTryte(t, val[2 * Tryte..]);
};
nullOrInt(t [Bool], val [Int]) = {
// concatenate the 3 separate shorts via the previous function
nullOrShort(t, val[0 * Short..]),
nullOrShort(t, val[1 * Short..]),
nullOrShort(t, val[2 * Short..]);
};
nullOrLong(t [Bool], val [Long]) = {
// concatenate the 3 separate ints via the previous function
nullOrInt(t, val[0 * Int..]),
nullOrInt(t, val[1 * Int..]),
nullOrInt(t, val[2 * Int..]);
};
nullOrHash(t [Bool], val [Hash]) = {
// concatenate the 3 separate longs via the previous function
nullOrLong(t, val[0 * Long..]),
nullOrLong(t, val[1 * Long..]),
nullOrLong(t, val[2 * Long..]);
};
nullOrState(t [Bool], val [State]) = {
// concatenate the 3 separate hashes via the previous function
nullOrHash(t, val[0 * Hash..]),
nullOrHash(t, val[1 * Hash..]),
nullOrHash(t, val[2 * Hash..]);
};
// sample old Curl implementation in Abra, just for fun
transform(state [State], round [Short]) = {
// assume subXxx() is a function that performs subtraction on trit vectors of size X
// and also returns a trit vector size X
roundMinusOne = sub9(round, 1);
// assume equalXxx() is a function that performs comparison on trit vectors of size X
// and returns a trit containing a binary boolean value of 0 (false) or 1 (true)
roundZero = equal9(roundMinusOne, 0);
// calculate the new state for this round
newState = curlRound(state);
// here comes the interesting part, we're going to use a merger operation,
// which is an operation that returns the single operand that is non-null
// note that a merger will fail when multiple operands are non-null
// this line will return newState when roundMinusOne was determined to be zero
// and null otherwise
stateOut = nullOrState(roundZero, newState);
// this line will return newState when roundMinusOne was determined to be non-zero
// and null otherwise
stateNext = nullOrState(not[roundZero], newState);
// this line will only return roundMinusone when it was non-zero and otherwise returns null
roundNext = nullOrShort(not[roundZero], roundMinusOne);
// recursively call transform to execute the next round
// note that this will only execute if either of stateNext and roundNext are non-null
// otherwise it will not execute and a null return value is assumed
// so this is essentially a conditional execution
stateFinal = transform(stateNext, roundNext);
// merge the two branches by returning the one that is non-null
// so this is kind of an implied if-then-else, because it will
// either return stateOut or stateFinal
stateOut \ stateFinal;
};
// now follows the actual implementation of a single Curl round
// LUT logic: curl the 2 input trits onto an output trit
curl [
-,- = 1;
-,0 = 0;
-,1 = -;
0,- = 1;
0,0 = -;
0,1 = 0;
1,- = -;
1,0 = 1;
1,1 = 0;
];
// a very dumb and straightforward implementation that curls all 729 state trits
curlRound(s [State]) = {
// we use the curl LUT for each of the 729 individual pairs of trits,
// and concatenate the resulting trits into a 729 trit return value
curl[s[ 0], s[364]],
curl[s[364], s[728]],
curl[s[728], s[363]],
// ... snipped 723 more lines like this ...
curl[s[366], s[ 1]],
curl[s[ 1], s[365]],
curl[s[365], s[ 0]];
};

原文链接:

https://blog.iota.org/qubic-status-update-september-3rd-2018-f981bdfd8f26

声明:链世界登载此文仅出于分享区块链知识,并不意味着赞同其观点或证实其描述。文章内容仅供参考,不构成投资建议。投资者据此操作,风险自担。此文如侵犯到您的合法权益,请联系我们100@7234.cn

    参与讨论 (0 人参与讨论)

    相关推荐

    比特币有什么缺点?

    1.交易平台的脆弱性。比特币网络很健壮,但比特币交易平台很脆弱。交易平台通常是一个网站,而网站会遭到黑客攻击,或者遭到主管部门的关闭。2.交易确认时间长。比特币钱包初次安装时,会消耗大量时间下载历史交易数据块。而比特币交易时,为了确认数据准确性,会消耗一些时间,与p2p网络进行交互,得到全网确认后,交易才算完成。3.价格波动极大。由于大量炒家介入,导致比特币兑换现金的价格如过山车一般起伏。使得比

    业务中使用区块链的四种方式

    业务中使用区块链的四种方式

    暴走时评:区块链是一种支持像比特币这样的数字货币的公共分类帐本,并且正改变着我们的业务方式。一旦那些对匿名交易,甚至是秘密交易感兴趣的人接纳了这样一种鲜为人知的工具,加密货币就会日趋成为主流。 区块链是一种支持像比特币这样的数字货币的公共分类帐本,并且正改变着我们的业务方式。一旦那些对匿名交易,甚至是秘密交易感兴趣的人接纳了这样一种鲜为人知的工具,加密货币就会日趋成为主流。越来越多的个人和企

    区块链:法定数字货币技术路线的必然选择

    区块链:法定数字货币技术路线的必然选择

    在人类发展史上,货币的进化从未停止。从物物交换,到金属铸币,再到纸质货币,以及当前正在发展的数字货币正在向着越来越便捷的方向进化。 比特币的出世起初并未带来轰动,但是最近几年其价格惊人的爬高创造出了一个个造富神话,引起各国政府及监管机构的关注。虽然金融专家普遍认为它只是一种资产,而非货币,但是,其背后的区块链(Blockchain)技术引起了包括各大金融机构、政府、企业及学术界的浓厚兴趣,未

    用区块链记录证书,证明真伪,墨尔本大学迈出了第一步

    用区块链记录证书,证明真伪,墨尔本大学迈出了第一步

    墨尔本大学宣布发起区块链认证和审核计划,允许通过一种隐私、安全且持久的方式验证学生的证书。 墨尔本大学正在试验一个区块链记录维护项目,允许接收者(即学生)存储他们的证书,出于核验目的,第三方也能访问这个系统。Learning Machine是这个发布系统的开发者,他们采用的是麻省理工媒体实验室(MIT Media Lab)在2016年提交的Blockcerts开源代码。 墨尔本大学副校长格雷

    日本IT巨头富士通联合日本“三大行”开发区块链p2p资金转移系统

    日本IT巨头富士通(Fujitsu)与三家大型银行已经宣布计划试点一项基于区块链创建的点对点资金转移系统。 通过与日本三大行——瑞穗金融集团,三井住友金融集团和三菱UFJ金融集团——的合作,富士通将现场试验一种基于云的区块链平台,用于在个体之间发送资金,并开发一款智能手机APP来提高这个系统的可用性。 从理论上讲,这个平台将把三大行的客户法定货币账户与这个区块链系统相连接。客户然后将能够使用这

    动画科普:什么是比特币?

    动画科普:什么是比特币?

    比特币(Bitcoin,简写BTC)概念由中本聪(化名)提出,是一种点对点、去中心化的数字资产;2009年,中本聪打包了第一个区块,并获得50枚比特币的挖矿奖励,挖矿奖励每4年减半一次,按此计算,比特币预计2140年发行完毕,总量为2100万枚。 随着比特币的发展,比特币逐渐受到认可:德国为全球首个接受比特币支付的国家;微软、戴尔等知名企业也纷纷接受比特币支付。 举个栗子,你能直接用比特币买到

    3分钟理解什么是公有链、私有链、联盟链、许可链

    不同的区块链有着不同的内涵和功能,在区块链领域经常出现的公有链、私有链、联盟链、许可链,这些又都代表什么意思呢? 公有链 公有链是指全世界任何人都可以随时进入系统中读取数据、发送可确认交易、竞争记账的区块链。公有链通常被认为是完全去中心化的,因为没有任何人或机构可以控制或篡改其中数据的读写。公有链一般会通过代币机制鼓励参与者竞争记账,来确保数据的安全性。比特币、以太坊都是典型的公有链。 私

    区块链是比特币的底层技术,但似乎两者已走上不同的道路

    区块链是比特币的底层技术,但似乎两者已走上不同的道路

    比特币的出现带来了一项新的技术——区块链,不过区块链和比特币似乎已走上了两条不一样道路,作为技术的区块链被越来越多的人所看好,而性质偏向于投资的比特币似乎被更多人看衰。 成也萧何败也萧何 比特币火爆的原因是其拥有去中心化、全世界流通、专属所有权、低交易费用、无隐藏成本、跨平台挖掘的特性,这些特性促使比特币成为了很多人关注的焦点。之后众多庄家的入局让比特币一瞬间成为了热门投资产业,但这几大特

    麦妖榜
    更新日期 2019-06-23
    排名用户贡献值
    1BitettFan24019
    2等待的宿命23809
    3六叶树20309
    4区块大康18727
    5牛市来了17561
    6linjm122716237
    7天下无双16192
    8lizhen00215160
    9让时间淡忘14486
    10冷风大q11188
    返回顶部 ↑