标签: modularity

请帮助分类组织C++/Lua游戏代码的方式并分离他们的职责.什么是最方便的方式,你使用哪一种？

例如,Lua可以仅用于初始化C++对象,也可以用于每次游戏循环迭代.它既可以用于游戏逻辑,也可以用于图形.一些游戏引擎提供对脚本中所有子系统的完全控制!我真的不喜欢这种方法(根本没有分离).

将所有游戏对象(npc,位置)实现为没有C++对象的Lua表是一个好主意吗？或者最好镜像它们(Lua表来控制C++对象)？或者是其他东西？

谢谢.

编辑.我的分类:Lua和C++:职责分离.

主题的延续:Lua,游戏状态和游戏循环

我已经开发了一个基于Java EE的Web应用程序作为一个开源项目。

现在，一些贡献者喜欢通过插入Web应用程序的模块来添加其他功能。

您能否解释一下如何实现这一目标，或将我引向参考文献。

我工作的地方它变得明显,一些管理任务应该是从公共网站独立多数民众赞成成长无论是在用户基础和功能点方面的站点.我想知道最好的办法是什么.

例如,该网站有一个很大的社交组件和一个公共销售界面.但与此同时,管理部分还有后台任务,批量上传处理,仪表板(长时间运行的查询)和客户关系工具,我希望不会受到公共交通高峰的影响(或影响公众 - 面对响应时间).

该站点运行在一个相当标准的Rails/MySQL/Linux堆栈上,但我认为这更像是一个架构问题,而不是一个实现问题:主要是,如何在这些不同的应用程序之间保持数据和业务逻辑同步？

我正在评估的一些策略:

1)在另一台机器上创建面向公众的数据库的从数据库. 提取出所有模型和库代码,以便可以在应用程序之间共享.为管理界面创建新的控制器和视图.

我对复制的经验有限,甚至不确定它是否应该以这种方式使用(大多数时候我已经看过它,它是用于扩展同一应用程序的读取功能,而不是具有多个不同的应用程序) .如果从站不在同一网络上,我也担心潜在的延迟问题.

2)创建新的更多任务/部门特定的应用程序,并使用面向消息的中间件来集成它们. 我读了一段时间的企业集成模式,他们似乎主张分布式系统.(或者,在某些情况下,基本的Rails风格的RESTful API功能可能就足够了.)但是,我有关于数据同步问题的噩梦以及这将带来的大规模重新架构.

3)两者的混合物. 例如,某些后台任务所需的唯一公共信息是只读完成时间或状态.将它放在一个完全独立的系统并将数据发送给公众是否有意义？同时,用户/组管理功能将在共享数据库的单独系统上运行？缺点是,这似乎保留了我对前两个问题的许多担忧,特别是重新构建.

我确信答案将高度依赖于网站的特定需求,但我很想听听成功(或失败)的故事.

我有一个相对较大的顶点图:524边:1125,是真实世界的交易.边缘是直的并且具有重量(包含是可选的).我正在尝试调查图中的各个社区,并且基本上需要一种方法:

- 计算所有可能的社区

- 计算最佳社区数量

- 返回每个(最佳)社区的成员/成员数量

到目前为止,我已经设法将以下代码汇总在一起,绘制了与各种社区相对应的颜色编码图,但是我不知道如何控制社区的数量(即绘制成员数最多的前5个社区)或列出特定社区的成员.

library(igraph)
edges <- read.csv('http://dl.dropbox.com/u/23776534/Facebook%20%5BEdges%5D.csv')
all<-graph.data.frame(edges)
summary(all)

all_eb <- edge.betweenness.community(all)
mods <- sapply(0:ecount(all), function(i) {
all2 <- delete.edges(all, all_eb$removed.edges[seq(length=i)])
cl <- clusters(all2)$membership
modularity(all, cl)
})


plot(mods, type="l")

all2<-delete.edges(all, all_eb$removed.edges[seq(length=which.max(mods)-1)])

V(all)$color=clusters(all2)$membership

all$layout <- layout.fruchterman.reingold(all,weight=V(all)$weigth)

plot(all, vertex.size=4, vertex.label=NA, vertex.frame.color="black", edge.color="grey",
edge.arrow.size=0.1,rescale=TRUE,vertex.label=NA, edge.width=.1,vertex.label.font=NA)

因为边缘介于中间方法执行得很差,我再次使用walktrap方法尝试:

all_wt<- walktrap.community(all, steps=6,modularity=TRUE,labels=TRUE)
all_wt_memb <- community.to.membership(all, all_wt$merges, steps=which.max(all_wt$modularity)-1)


colbar <- rainbow(20)
col_wt<- colbar[all_wt_memb$membership+1]

l <- layout.fruchterman.reingold(all, niter=100)
plot(all, layout=l, vertex.size=3, vertex.color=col_wt, vertex.label=NA,edge.arrow.size=0.01,
                    main="Walktrap Method")
all_wt_memb$csize
[1] 176  13 204  24   9 263 …

我正在为一个项目制作几个Android库应用程序.为了简化问题,假设我在这个项目中有两个库(utilLib,screenLib)(现在将被称为app).

每个项目中都有相同名称的String资源,但值不同.像这样:

utilLib

<string name="app_version">1.0</string>
<string name="hello">UtilLib Hello</string>

screenLib

<string name="app_version">0.7a</string>
<string name="hello">ScreenLib Hello</string>

应用

<string name="app_version">0.1</string>

我意识到我可以使用com.package.R来引用该字符串,但是如果我的代码看起来会出现什么呢？

<!-- language: java -->
import com.app.R; 
...

private void checkValue(){
    String version = getString(R.app_version);
    Log.d(TAG, "version: " + version); // 0.1 show be here
    String hello = getString(R.hello);
    Log.d(TAG, "Hello: " + hello); // <---- ? ('UtilLib Hello' or 'ScreenLib Hello')
}

我试图在这里进行模块化构建,但不完全理解Android如何优先使用它的R.java.有没有人经历过这个？

当我从头开始编写代码时,我养成了在一个函数中快速编写所有内容的坏习惯,整个时间都在考虑"我将在以后更加模块化".然后,当后来出现时,我有一个工作产品,任何修复它的尝试都意味着创建功能,并且必须弄清楚我需要通过什么.

它变得最糟糕,因为当你的项目几乎完成时重新设计类变得非常困难.例如,我通常在开始编写代码之前做一些规划,然后当我的项目完成时,我意识到我可以使类更加模块化和/或我可以使用继承.基本上,我认为我没有做足够的计划,而且我不会获得超过一个级别的抽象.

所以最后,我坚持使用一个具有大型主函数,一个类和一些辅助函数的程序.不用说,它不是非常可重复使用的.

有没有人有同样的问题,有任何提示可以克服这个问题？我想到的一件事是用pseduocode编写main函数(没有太多细节,但足以看到他们需要什么对象和函数).本质上是一种自上而下的方法.

这是一个好主意吗？还有其他建议吗？

尝试使用Unity和Prism初始化模块时出现以下错误.该DLL被发现

return new DirectoryModuleCatalog() { ModulePath = @".\Modules" };

找到dll并找到名称

  #region Constructors

    public AdminModule(
        IUnityContainer container,
        IScreenFactoryRegistry screenFactoryRegistry,
        IEventAggregator eventAggregator,
        IBusyService busyService
        )
        : base(container, screenFactoryRegistry)
    {
        this.EventAggregator = eventAggregator;
        this.BusyService = busyService;
    }

    #endregion

    #region Properties

    protected IEventAggregator EventAggregator { get; set; }
    protected IBusyService BusyService { get; set; }

    #endregion

    public override void Initialize()
    {
        base.Initialize();
    }

    #region Register Screen Factories

    protected override void RegisterScreenFactories()
    {
        this.ScreenFactoryRegistry.Register(ScreenKeyType.ApplicationAdmin, typeof(AdminScreenFactory));
    }

    #endregion

    #region Register Views and Various Services

    protected override …

我正在创建一个应用程序来解析MSDN文章中的元信息,例如文章标题和同一集合中的其他文章.这个应用程序还有一个GUI前端.

我有兴趣通过将前端与后端和后端分成两部分来使这个程序更加模块化 - 一个用于处理HTML文档的检索和一般解析,另一个用于更具体的解析解析与MSDN本身有关.这个想法是,这将允许自定义UI被打到后端,并允许应用程序只需通过插入不同的DLL来解析其他站点(可能是谷歌搜索结果).

我的理解是,您通常会创建DLL以跨不同的应用程序共享代码.但是,在这种情况下,我只是在寻找这个特定应用程序的模块化.在这种情况下创建DLL仍然合适吗？或者我应该考虑一个不同的选项,例如将所有类组合成一个组件？

我应该注意到我对编程比较陌生,所以即使答案是"不",那么这对我来说仍然是一个很好的练习.如果是这种情况,我想知道是否应该修改此练习以使其更合适.

我有一个庞大的路由器网络,所有路由器都在社区网络中互连.我试图通过不同的方式分析这个网络并获得有用的见解以及通过分析图表(使用gephi)来改进它的方法.所以我遇到了这个称为"模块化"的措施,其定义为:

衡量网络划分为模块(也称为组,集群或社区)的强度.具有高模块性的网络在模块内的节点之间具有密集连接,但是在不同模块中的节点之间具有稀疏连接.

我的问题是,通过使用"模块化"度量,我可以从网络中学到什么？例如,当我在gephi中使用它时,每个网段都会对网络进行着色,但它有什么用呢？

我已经在 python lib NetorwkX 中创建了一个图，我想实现一个模块化算法来聚集我的图的节点。我遇到了以下代码：

import community
import matplotlib.pyplot as plt
import networkx as nx

G = nx.Graph()

G = nx.read_weighted_edgelist('graphs/fashionGraph_1.edgelist')
nx.transitivity(G)

# Find modularity
part = community.best_partition(G)
mod = community.modularity(part,G)

# Plot, color nodes using community structure
values = [part.get(node) for node in G.nodes()]
nx.draw_spring(G, cmap=plt.get_cmap('jet'), node_color = values, node_size=30, with_labels=False)
plt.show()

我的图有 4267 和 3692 条边。结果图是这样的：

我对图的节点是如何聚集的有点困惑。哪些是颜色的逻辑？