小编Hug*_*ira的帖子

我已经开始使用Akka和Scala在面向总线的架构中开发一组交互组件.我需要测试系统的容错性,为此我想知道是否有任何方法可以在Scala测试框架内使用概率失效模型(即为每个Actor设置一些失败参数).有任何想法吗？那个已经实现了这个的框架？

考虑以下类别定义:

trait Category[~>[_, _]] {
  def id[A]: A ~> A
  def compose[A, B, C](f: A ~> B)(g: B ~> C): A ~> C
}

这是一元函数的实例:

object Category {
  implicit def fCat = new Category[Function1] {
    def id[A] = identity
    def compose[A, B, C](f: A => B)(g: B => C) = g.compose(f)
  }
}

现在,类别受到一些法律的约束.关于composition(.)和identity(id):

forall f: categoryArrow -> id . f == f . id == f

我想用ScalaCheck测试一下.让我们尝试整数函数:

"Categories" should {
  import Category._

  val intG  = …

我需要在Scala中有一个非常非常长的对(X,Y)列表.如此之大,它不适合内存(但很适合在磁盘上).

• 所有更新操作都是缺点(头部追加).
• 所有读取访问都从头部开始,并有序地遍历列表,直到找到预定的对.
• 缓存会很棒,因为大多数读访问都会反复保留相同的数据.

所以,这基本上是一个"磁盘持久 - 懒惰 - 可缓存列表"™

在我开始推出自己的产品之前,有关如何获得一个的想法吗？

附录:是.. mongodb,或任何其他非可嵌入资源,是一种矫枉过正.如果您对此特定用例感兴趣,请参阅Timeline 此处的课程.基本上,我有一个非常非常大的时间线(几个月内数百万对),虽然我的比赛只需要触及最后几个小时.

考虑解决100名囚犯的标准策略和灯泡问题.这是我在Dafny模拟它的尝试:

method strategy<T>(P: set<T>, Special: T) returns (count: int)
  requires |P| > 1 && Special in P
  ensures count == (|P| - 1)
  decreases *
{
  count := 0;
  var I := {};
  var S := {};
  var switch := false;

  while (count < (|P|-1)) 
    invariant count <= (|P|-1) 
    invariant count > 0 ==> Special in I
    invariant Special !in S && S < P && S <= I && I <= P 
    decreases *
  { …

有没有办法强制IntelliJ使用特定的字体变体,例如 Source Code Pro Light？据我所知,永远的IntelliJ假设经常变的,不允许一个指定哪些要使用粗体和斜体.

我可能还不清楚.有一种方法可以选择固定变量(粗体和斜体),但IntelliJ决定该变体应该是什么.例如,考虑我要配置IntelliJ以使用以下字体的事实:

• 普通文本- >源代码临光(而不是常规)
• 粗体 - >源代码专业定期(而不是粗体)
• Italic - >源代码Pro Powerline Italic(不一样的字体)

考虑以下(大大简化)代码:

public T Function<T>() {
    if (typeof(T) == typeof(string)) {
        return (T) (object) "hello";
    }
    ...
}

首先施展到object那时是荒谬的T.但编译器无法知道先前的测试确保T类型string.

在C#中实现这种行为的最优雅,惯用的方式是什么(包括摆脱愚蠢typeof(T) == typeof(string),因为T is string不能使用)？

附录: .net中没有返回类型差异,因此你不能让函数重载来输入字符串(顺便说一下,这只是一个例子,但是多态性中关联结束重定义的一个原因,例如UML,可以不能用c#完成.显然,以下将是伟大的,但它不起作用:

public T Function<T>() {
    ...
}

public string Function<string>() {
    return "hello";
}

具体示例1:因为针对特定类型测试的通用函数不是通用的,所以有几次攻击,我将尝试提供更完整的示例.考虑Type-Square设计模式.以下是一个片段:

public class Entity {
  Dictionary<PropertyType, object> properties;

  public T GetTypedProperty<T>(PropertyType p) {
    var val = properties[p];

    if (typeof(T) == typeof(string) {
      (T) (object) p.ToString(this);  // magic going here …

我试图绕过头async/await,我有以下代码:

class AsyncQueue<T> {
    queue = Array<T>()
    maxSize = 1

    async enqueue(x: T) {
        if (this.queue.length > this.maxSize) {
            // Block until available
        }

        this.queue.unshift(x)
    }

    async dequeue() {
        if (this.queue.length == 0) {
            // Block until available
        }

        return this.queue.pop()!
    }
}

async function produce<T>(q: AsyncQueue, x: T) {
    await q.enqueue(x)
}

async function consume<T>(q: AsyncQueue): T {
    return await q.dequeue()
}

// Expecting 3 4 in the console
(async () => {
    const q = new …

所以...

我教授软件工程中的正式方法.我还教授"敏捷方法论".大多数人似乎认为这是矛盾的.我认为这很有意义......我也在一家公司工作,我们需要在那里完成任务:)虽然我可以在日常的基础上应用我所获得的技能点"我的规格",同事们通常会逃避"正式"这个词.

我曾经认为这是由于我们学习如何编程的内在方式:我们通常会找到一个有效的解决方案而不是理解问题.然后我认为这是因为正式社区中的大多数人不是工程师,而是数学家或计算机科学家.如今,我想知道是否只是因为正式方法社区隐藏在某种"混淆"法律背后,使用所有可用的UNICODE符号,积极开发粗鲁,不实用的工具,并在标准面前笑.

是的,我一直在从"责备他们"转变为"责备我们"的观点;-)

所以,我的问题是:你在公司使用任何形式的方法吗？你介绍过它们,还是它们的先决条件？你用什么技巧来消除人们的恐惧中的数学迷雾,并煽动他们使用正式的方法？您认为目前的工具缺乏更普遍的用途？

我正在寻找一个无脑应用程序,它允许我通过蓝牙连接发送预定义的命令列表,或者在OSX(64位)中正常工作的等效Java/Scala库.

简而言之,我想用我的电脑"模拟"蓝牙配件,所以我必须能够控制配对,交换的代码等等......

思考？

当使用阿卡,我把akka.conf在src/main/resources.当我run通过sbt时,akka.conf正确识别.但是当我通过IntelliJ(即使在a之后gen-idea)运行时.完成此任务的适当方法是什么？