标签: modularity

考虑这段代码:

isPrime primes' n = foldr (\p r -> p * p > n || (n `rem` p /= 0 && r)) True primes'

primes = 2 : filter (isPrime primes) [3..]

main = putStrLn $ show $ sum $ takeWhile (< 1000000) primes

它计算低于一百万的所有素数之和.在我的机器上打印结果需要0.468秒.但如果定义isPrime和primes被提取到另一个模块,时间成本是1.23秒,它几乎慢3倍.

当然,我可以在任何需要的地方复制/粘贴定义,但我也很好奇为什么会发生这种情况,以及如何解决它.

[编辑] 我正在使用GHC 7.0.3(Windows 7 + MinGW).代码是用EclipseFP编写的(它使用Scion作为IDE后端),并内置到带有-O2标志的可执行文件中.

我也尝试在IDE之外构建包:

executable test
  hs-source-dirs:  src
  main-is:         Main.hs
  build-depends:   base >= 4
  ghc-options:     -O2
  other-modules:   Primes

executable test2
  hs-source-dirs: …

我尝试使用AngularJS构建模块化应用程序.我的第一个想法是通过functionnality将每个模块分组为这种文件夹结构:

/core 
    controllers.js
    directives.js
    app.js
/modules
     /users
        controllers.js
        directives.js
     /invoices
        controllers.js
        directives.js
     /messages        
        controllers.js
        directives.js
     ...

请注意,"core"文件夹包含将始终位于应用程序中的基本功能.其他模块可以单独添加或删除.

由于我的应用程序很大,我也想使用延迟加载.我实现了这个解决方案:http://ify.io/lazy-loading-in-angularjs/在我看来实际上是最简单的方法.问题是它只对控制器,服务,指令进行延迟加载......但不适用于AngularJS模块.

我知道还有另一种允许延迟加载Angular模块的方法(http://blog.getelementsbyidea.com/load-a-module-on-demand-with-angularjs/)但是我认为这太过于hacky,因为它使用Angular的核心方法.

我的问题是:在我的情况下,为我的每个模块使用不同的AngularJS模块是否有意义,如下所示:

angular.module('core', ['ngRoute', 'users', 'invoices', 'messages'])
angular.module('users')
angular.module('invoices')
angular.module('messages')

这种方法的优点是什么？AngularJS模块目前是否有用 - 仅适用于Angular的第三方模块？

我问这个,因为AngularJS 2.0将支持本机延迟加载.来自Google的MiškoHevery说"你应该按视图分组,因为在不久的将来,视图将被延迟加载",并且我们应该为每个应用程序使用一个模块,请参阅此处:https://www.youtube.com/watch？ v =&ZhfUv0spHCY T = 34m19s

对于大型应用程序来说,只为我的应用程序使用一个模块是正确的,如下所示:

angular.module('core', ['ngRoute']);

然后根据路由或视图延迟加载我的控制器,服务和指令？

如果我想使用DIP开发一个假设的模块化C++项目.由于模块化,我选择在一个库中完全实现一个特定功能A.另一个库B(或两个或三个......)正在使用此功能(例如,日志记录机制):

class ILogger
{
    virtual void log(const std::string& s) = 0;
};

我应该把这个界面放在哪里？一些博主似乎建议,因为界面属于其用户(因为DIP),你应该将界面放在用户端(或这里).这也可以提高可测试性,因为您不需要任何实现链接到测试.

这意味着,库A本身不会编译,因为它缺少接口.这也意味着,如果库C也将使用日志记录工具,它还会引入一个接口ILogger,这将打破ODR？这可以通过引入仅包含接口的额外包层库来解决.但主要问题仍然存在:

在哪里放置界面？我阅读了关于DIP 的原始论文,但我不同意解释,我不应该将接口放入库中.我觉得这篇论文是作为如何思考开发的指导原则(因为"用户正在定义界面而不是实现者").它是否正确？你如何使用依赖倒置原则？

似乎每次我编写任何处理提取,推送,读取或写入操作的代码时,整个代码段都是临时的,丑陋的,并且在该确切应用程序的上下文之外完全无法使用.更糟糕的是,每当我设计这些东西时,我都必须重新发明轮子.在我看来,I/O操作的本质是非常线性的,并不适合模块化或面向对象的模式.

我真的希望有人能告诉我这里错了.是否存在面向对象或模块化文件和数据I/O的技术/模式？我可以遵循一些约定来添加一些代码重用性吗？我知道存在各种工具来简化单个文件的读取,比如XML解析器等,但我指的是使用这些工具的较大设计.

问题不仅限于单一语言; 我在Java,C,Matlab,Python和其他人中遇到过同样的问题.

这个问题的子主题是关于什么对象应该调用保存的问题.这个问题似乎是指工厂模式,其中文件的内容被构建,然后最终写入磁盘.我的问题是关于整体架构,包括用于写操作的工厂,还有用于读取/获取操作的(Insert Pattern Here).

我能想到的最好的东西是外立面图案......但圣洁的烟雾是那些丑陋的立面的代码.

有人请告诉我一个模式,我可以重新使用我的一些代码,或者至少遵循一个模板用于将来的读写.

有人在这里询问模块化设计,但答案是针对该提问者的问题,并不是完全有用的.

例

这只是一个例子,它基于我去年做的一个项目.随意提供一个不同的例子.

我们的程序是一个物理沙箱.我们想要加载描述该沙箱中对象的物理属性的XML数据.我们还需要加载包含3D渲染信息的.3DS文件.最后,我们需要查询SQL数据库以找出谁拥有哪些对象.

我们还需要能够支持3D模型格式.我们还不知道那些文件会是什么样子,但我们希望提前设置代码框架.这样,一旦我们获得新的数据模式,就可以快速实现加载例程.

来自所有3个来源的数据将用于在我们的软件中创建对象的实例.

之后,我们需要将物理信息(如位置和速度)保存到数据库,并将自定义纹理信息保存到本地文件.我们不知道纹理的文件类型是什么,所以我们只想布置代码结构,以便我们以后可以输入保存代码.

如果没有某种设计模式,即使是少量的对象也会迅速导致紧密耦合的网络.

外观可以将对象/数据与相应的文件分离,但所有这一切都将问题集中在输入和输出外观中,这可能会在匆忙中变成一场噩梦般的混乱.此外,对象/数据现在与立面紧密耦合,因此实际上没有获得模块化.

从3周前编辑...

以前,我提出了一堆伪问题来解决我第一次提出这个问题时遇到的问题,但我已经决定它混淆了我的主要问题.我只想说:我必须在这个特定的读取操作集中使用大约2000行真正不稳定的代码,它在处理和组织方面做得非常少,而且我再也无法在另一个项目上使用它了.

我想避免将来编写这样的代码.

我正试图找出使用akka-http和akka-streams实现真正的websocket应用程序的最佳方法.我最想要的是简单性,我现在还没有得到它.

假设您有一个相当复杂的管道,需要区分多个请求,有时会将请求发送给actor进行处理,有时会发出mongo查询并返回响应,有时会在REST API上执行PUT等.

与那里的简单聊天应用程序示例不同,出现至少3个似乎没有标准解决方案的问题:

• 有条件地跳过响应,例如,因为客户端不期望该请求将收到响应.如果我使用从消息到消息的典型流程,一旦请求到达其目标,我需要阻止它进一步传播回websocket.它可以使用特殊的过滤器(涉及一些痛苦)或使用各种其他方式(例如,使用akka流有条件地跳过流)来完成,但这增加了许多样板和复杂性.理想情况下,我希望能够插入跳过其他所有内容的"跳过"消息.

• 将传入消息路由到适当的位置(例如,actor,mongo).再一次,我可以找到涉及大量样板的解决方案(例如,在不处理此类请求的分支处进行广播和过滤).理想情况下,我应该能够定义如下内容:如果消息是X,则将其发送到那里,如果消息是Y,则将其发送到那里等.

• 将错误传播回客户端.非常类似于上面描述的路由问题.例如,如果JSON解析失败,我需要添加一个单独的路径(广播+合并),我发送错误消息,但如果在下一阶段发生错误,我甚至无法轻易地重用相同的路径,我想将该错误传播给用户.理想情况下,我应该有一个单独的错误处理路径,可以在流中的任意点使用,完全绕过流的其余部分并返回到客户端.

目前,我有这个非常复杂的图表,跨越15行,路径经过> 20个不同的阶段,我真的很担心要保持这个解决方案的复杂性.DSL在这个尺寸上几乎是不可读的.我当然可以更好地模块化,但这对于一些应该简单得多的事情来说就像是一个疯狂的麻烦.

我错过了什么吗？考虑到akka-streams这样的任务,我是疯了吗？任何可以让我控制所有复杂性的想法或代码示例？

提前致谢!

由于一个小的规格改变,我发现了一件工作被扔掉了,结果证明没有正确规定.如果在项目开始时就已经完成,那么大部分工作从一开始就不需要.

有哪些好的提示/设计原则可以防止这些事情发生？

或者为了在实现过程中实现功能请求或设计更改,减少重新编写代码所需的数量？

我的游戏引擎由一系列松散耦合的模块组成,可以加载和卸载.

一些示例是:基本模块,处理窗口管理和响应OS事件,实体管理器,Lua管理器,物理管理器.

现在,这些模块被组织为命名空间,它们的状态通过相应源文件中的局部变量来定义.每个命名空间都有一个Open(),Close()和Update()函数.

现在,我真的不喜欢名称空间的解决方案了.

• 它不够灵活

• 即使在现实中可能不需要它,具有创建模块的多个实例的简单能力似乎是正确的

• 好像我在这里没有使用OOP - 一个带有虚拟Update()成员函数的模块基类听起来更合理

• 当模块关闭并重新打开时,更难以确保所有变量也将被重置(具有构造函数和析构函数的类将更容易)

• 如果没有显式调用Open(),Close()和Update(),就无法正确管理模块

所以,我的想法会一直使用类为每个模块,从模块基类派生.模块类实例将由ModuleManager类处理,后者会更新它们.

但是OOP的解决方案带来了模块应该如何通信的问题.现在,基础模块告诉控制台模块打印一些东西console::print()

• 如何解决这个问题而不必使用类似的东西g_ModuleManager.GetConsoleModule()->print()？

• 这个模块管理器怎么能详细工作？

我的最后一个问题是:

• 对于使用OOP用C++编写模块化游戏引擎这个主题,你有什么进一步的提示吗？

• 是否有任何设计模式可以帮助我在这种情况下,甚至可能是具体的阅读材料？

伙计们!

我是一名具有Java背景的软件开发人员,我正在使用Ruby Web框架(Padrino/Sinatra)开始一些项目.

在我的java项目中,我通常有一些"常见"项目,其中的类在几个项目中使用.例如,我有一个中央身份验证服务,以及一个存储用户配置文件的共享数据库.我使用此服务的所有项目共享一些映射到用户配置文件数据库的模型.

所以,尽管有框架,orm lib等,在多个Ruby项目中共享代码的最佳方式是什么？

我g在python-igraph中有一个图形.我可以通过VertexCluster以下方式获得社区结构:

community = g.community_multilevel()

community.membership 给我一个图表中所有顶点的组成员资格列表.

我的问题非常简单,但我还没有找到特定于python的答案.如何使用其社区结构的可视化绘制图形？最好是PDF,所以像

layout = g.layout("kk")
plot(g, "graph.pdf", layout=layout) # Community detection?

非常感谢.

我正在努力深入理解ML风格的模块:我认为这个概念很重要,我喜欢他们鼓励的那种思维方式.我刚刚发现参数类型和参数模块之间可能出现的张力.我正在寻找工具来思考这个问题,这将有助于我在构建程序时做出明智的设计决策.

拳头我将试着总体上描述我的问题.然后我将从我正在研究的学习项目中提供一个具体的例子.最后,我将重新审视一般性问题,以便将其引入一定程度.

(对不起,我还不太了解这个问题更简洁.)

总的来说,我发现的紧张是:当我们为它们提供参数类型签名(适当时)时,函数是最灵活的,并且对最广泛的重用开放.但是,当我们在模块内部封闭函数的参数化时,模块是最灵活的,并且对最广泛的重用是开放的,而是在给定类型上参数化整个模块.

在将实现LIST签名的模块与实现签名的 模块进行比较时,可以找到这种差异的现成示例ORD_SET.模块List:LIST提供了许多有用的函数,可以在任何类型上进行参数化.一旦我们定义或加载了一个List模块,我们就可以轻松地应用它提供的任何功能来构造,操作或检查任何类型的列表.例如,如果我们使用字符串和整数,我们可以使用同一个模块来构造和操作两种类型的值:

val strList = List.@ (["a","b"], ["c","d"])
val intList = List.@ ([1,2,3,4], [5,6,7,8])

另一方面,如果我们想要处理有序集合,那么事情是不同的:有序集合要求有序关系保持其所有元素,并且没有单个具体函数compare : 'a * 'a -> order 为每种类型产生该关系.因此,我们需要一个不同的模块来满足ORD_SET我们希望放入有序集合的每种类型的签名.因此,为了构造或操纵有序的字符串和整数集,我们必须为每种类型实现不同的模块[1]:

structure IntOrdSet = BinarySetFn ( type ord_key = int
                                    val compare = Int.compare )
structure StrOrdSet = BinarySetFn ( type ord_key = string
                                    val compare = String.compare )

然后,当我们希望对给定类型进行操作时,我们必须使用适当模块中的拟合函数:

val strSet = StrOrdSet.fromList ["a","b","c"]
val intSet = IntOrdSet.fromList [1,2,3,4,5,6]

这里有一个非常直接的权衡:LIST模块提供的范围超出你喜欢的任何类型的函数,但它们不能利用任何特定类型的值之间的任何关系; ORD_SET …